Update to v085 release.

byuu says:

A new release for the new year.

Changelog:
fixed auto joypad polling edge case; fixes Ys 5 controls
fixed Justifier polling code; Lethal Enforcers should be fully
responsive once again
rewrote SNES S-SMP processor core (~20% code reduction)
fixed Game Boy 8x16 sprite mode; fixed some sprites in Zelda: Link's
Awakening
treat Game Boy HuC1 RAM enable flag as writable flag instead; fixes
Pokemon Card GB
created far faster XML parser; bsnes can now load XML files once again
updated to mightymo's most recent cheat code database
internal color calculations now performed at 30-bits per pixel
gamma slider now acts as fine-tuned gamma ramp option
Linux OpenGL driver will output at 30bpp on capable displays
Linux port defaults to GTK+ now instead of Qt (both are still available)

bsnes/Makefile

@@ -12,7 +12,7 @@ ui := ui
 # 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 +29,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)
@@ -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 data gameboy libco nall nes obj out phoenix ruby snes ui ui-libsnes Makefile cc.bat clean.bat
 
 help:;

bsnes/gameboy/Makefile

@@ -1,7 +1,7 @@
 gameboy_objects := gameboy-interface gameboy-system gameboy-scheduler
 gameboy_objects += gameboy-memory gameboy-cartridge
 gameboy_objects += gameboy-cpu gameboy-apu gameboy-lcd
-gameboy_objects += gameboy-cheat
+gameboy_objects += gameboy-cheat gameboy-video
 objects += $(gameboy_objects)
 
 obj/gameboy-interface.o: $(gameboy)/interface/interface.cpp $(call rwildcard,$(gameboy)/interface/)
@@ -13,3 +13,4 @@ obj/gameboy-cpu.o: $(gameboy)/cpu/cpu.cpp $(call rwildcard,$(gameboy)/cpu/)
 obj/gameboy-apu.o: $(gameboy)/apu/apu.cpp $(call rwildcard,$(gameboy)/apu/)
 obj/gameboy-lcd.o: $(gameboy)/lcd/lcd.cpp $(call rwildcard,$(gameboy)/lcd/)
 obj/gameboy-cheat.o: $(gameboy)/cheat/cheat.cpp $(call rwildcard,$(gameboy)/cheat/)
+obj/gameboy-video.o: $(gameboy)/video/video.cpp $(call rwildcard,$(gameboy)/video/)

bsnes/gameboy/apu/apu.cpp

@@ -47,12 +47,14 @@ void APU::main() {
     master.run();
 
     interface->audioSample(master.center, master.left, master.right);
-    if(++clock >= 0) co_switch(scheduler.active_thread = cpu.thread);
+
+    clock += 1 * cpu.frequency;
+    if(clock >= 0) co_switch(scheduler.active_thread = cpu.thread);
   }
 }
 
 void APU::power() {
-  create(Main, 4194304);
+  create(Main, 4 * 1024 * 1024);
   for(unsigned n = 0xff10; n <= 0xff3f; n++) bus.mmio[n] = this;
 
   for(auto &n : mmio_data) n = 0x00;

bsnes/gameboy/apu/master/master.cpp

@@ -1,11 +1,6 @@
 #ifdef APU_CPP
 
 void APU::Master::run() {
-  static int16_t volume[] = {
-    -16384, -14336, -12288, -10240,  -8192,  -6144,  -4096,  -2048,
-     +2048,  +4096,  +6144,  +8192, +10240, +12288, +14336, +16384,
-  };
-
   if(enable == false) {
     center = 0;
     left   = 0;
@@ -13,22 +8,19 @@ void APU::Master::run() {
     return;
   }
 
-  signed sample = 0, channels;
+  signed sample = 0;
   sample += apu.square1.output;
   sample += apu.square2.output;
   sample +=    apu.wave.output;
   sample +=   apu.noise.output;
-  sample >>= 2;
-  center = volume[sample];
+  center = (sample * 512) - 16384;
 
   sample = 0;
-  channels = 0;
-  if(channel1_left_enable) { sample += apu.square1.output; channels++; }
-  if(channel2_left_enable) { sample += apu.square2.output; channels++; }
-  if(channel3_left_enable) { sample +=    apu.wave.output; channels++; }
-  if(channel4_left_enable) { sample +=   apu.noise.output; channels++; }
-  if(channels) sample /= channels;
-  left = volume[sample];
+  if(channel1_left_enable) sample += apu.square1.output;
+  if(channel2_left_enable) sample += apu.square2.output;
+  if(channel3_left_enable) sample +=    apu.wave.output;
+  if(channel4_left_enable) sample +=   apu.noise.output;
+  left = (sample * 512) - 16384;
 
   switch(left_volume) {
     case 0: left >>= 3;                       break;  // 12.5%
@@ -42,13 +34,11 @@ void APU::Master::run() {
   }
 
   sample = 0;
-  channels = 0;
-  if(channel1_right_enable) { sample += apu.square1.output; channels++; }
-  if(channel2_right_enable) { sample += apu.square2.output; channels++; }
-  if(channel3_right_enable) { sample +=    apu.wave.output; channels++; }
-  if(channel4_right_enable) { sample +=   apu.noise.output; channels++; }
-  if(channels) sample /= channels;
-  right = volume[sample];
+  if(channel1_right_enable) sample += apu.square1.output;
+  if(channel2_right_enable) sample += apu.square2.output;
+  if(channel3_right_enable) sample +=    apu.wave.output;
+  if(channel4_right_enable) sample +=   apu.noise.output;
+  right = (sample * 512) - 16384;
 
   switch(right_volume) {
     case 0: right >>= 3;                         break;  // 12.5%

bsnes/gameboy/apu/serialization.cpp

@@ -1,6 +1,8 @@
 #ifdef APU_CPP
 
 void APU::serialize(serializer &s) {
+  Processor::serialize(s);
+
   s.array(mmio_data);
   s.integer(sequencer_base);
   s.integer(sequencer_step);

bsnes/gameboy/cartridge/cartridge.cpp

@@ -16,14 +16,11 @@ namespace GameBoy {
 #include "serialization.cpp"
 Cartridge cartridge;
 
-void Cartridge::load(const string &markup, const uint8_t *data, unsigned size) {
+void Cartridge::load(System::Revision revision, const string &markup, const uint8_t *data, unsigned size) {
   if(size == 0) size = 32768;
   romdata = allocate<uint8>(romsize = size, 0xff);
   if(data) memcpy(romdata, data, size);
 
-//uint32_t crc = crc32_calculate(data, size);
-//print("CRC32 = ", hex<4>(crc), "\n");
-
   info.mapper = Mapper::Unknown;
   info.ram = false;
   info.battery = false;
@@ -33,9 +30,9 @@ void Cartridge::load(const string &markup, const uint8_t *data, unsigned size) {
   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;
@@ -45,12 +42,12 @@ void Cartridge::load(const string &markup, const uint8_t *data, unsigned size) {
   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 = hex(document["cartridge"]["rom"]["size"].data);
+  info.ramsize = hex(document["cartridge"]["ram"]["size"].data);
+  info.battery = document["cartridge"]["ram"]["battery"].data == "true";
 
   switch(info.mapper) { default:
     case Mapper::MBC0:  mapper = &mbc0;  break;
@@ -64,7 +61,7 @@ void Cartridge::load(const string &markup, const uint8_t *data, unsigned size) {
   }
 
   ramdata = new uint8_t[ramsize = info.ramsize]();
-  system.load();
+  system.load(revision);
 
   loaded = true;
   sha256 = nall::sha256(romdata, romsize);
@@ -101,12 +98,28 @@ void Cartridge::ram_write(unsigned addr, uint8 data) {
 }
 
 uint8 Cartridge::mmio_read(uint16 addr) {
-  if(bootrom_enable && within<0x0000, 0x00ff>(addr)) return System::BootROM::sgb[addr];
+  if(addr == 0xff50) return 0x00;
+
+  if(bootrom_enable) {
+    const uint8 *data = nullptr;
+    switch(system.revision()) { default:
+    case System::Revision::GameBoy: data = System::BootROM::dmg; break;
+    case System::Revision::SuperGameBoy: data = System::BootROM::sgb; break;
+    case System::Revision::GameBoyColor: data = System::BootROM::cgb; break;
+    }
+    if(addr >= 0x0000 && addr <= 0x00ff) return data[addr];
+    if(addr >= 0x0200 && addr <= 0x08ff && system.cgb()) return data[addr - 256];
+  }
+
   return mapper->mmio_read(addr);
 }
 
 void Cartridge::mmio_write(uint16 addr, uint8 data) {
-  if(bootrom_enable && addr == 0xff50) bootrom_enable = false;
+  if(bootrom_enable && addr == 0xff50) {
+    bootrom_enable = false;
+    return;
+  }
+
   mapper->mmio_write(addr, data);
 }
 

bsnes/gameboy/cartridge/cartridge.hpp

@@ -45,7 +45,7 @@ struct Cartridge : MMIO, property<Cartridge> {
   MMIO *mapper;
   bool bootrom_enable;
 
-  void load(const string &markup, const uint8_t *data, unsigned size);
+  void load(System::Revision revision, const string &markup, const uint8_t *data, unsigned size);
   void unload();
 
   uint8 rom_read(unsigned addr);

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/cpu/core/core.cpp

@@ -571,6 +571,13 @@ void CPU::op_halt() {
 }
 
 void CPU::op_stop() {
+  if(status.speed_switch) {
+    status.speed_switch = 0;
+    status.speed_double ^= 1;
+    frequency = 4 * 1024 * 1024;
+    if(status.speed_double) frequency *= 2;
+    return;
+  }
   status.stop = true;
   while(status.stop == true) op_io();
 }

bsnes/gameboy/cpu/cpu.cpp

@@ -94,15 +94,43 @@ void CPU::interrupt_exec(uint16 pc) {
 }
 
 void CPU::power() {
-  create(Main, 4194304);
+  create(Main, 4 * 1024 * 1024);
 
   for(unsigned n = 0xc000; n <= 0xdfff; n++) bus.mmio[n] = this;  //WRAM
   for(unsigned n = 0xe000; n <= 0xfdff; n++) bus.mmio[n] = this;  //WRAM (mirror)
-  for(unsigned n = 0xff00; n <= 0xff0f; n++) bus.mmio[n] = this;  //MMIO
-  for(unsigned n = 0xff80; n <= 0xffff; n++) bus.mmio[n] = this;  //HRAM+IE
+  for(unsigned n = 0xff80; n <= 0xfffe; n++) bus.mmio[n] = this;  //HRAM
 
-  for(unsigned n = 0; n < 8192; n++) wram[n] = 0x00;
-  for(unsigned n = 0; n <  128; n++) hram[n] = 0x00;
+  bus.mmio[0xff00] = this;  //JOYP
+  bus.mmio[0xff01] = this;  //SB
+  bus.mmio[0xff02] = this;  //SC
+  bus.mmio[0xff04] = this;  //DIV
+  bus.mmio[0xff05] = this;  //TIMA
+  bus.mmio[0xff06] = this;  //TMA
+  bus.mmio[0xff07] = this;  //TAC
+  bus.mmio[0xff0f] = this;  //IF
+  bus.mmio[0xff46] = this;  //DMA
+  bus.mmio[0xffff] = this;  //IE
+
+  if(system.cgb()) {
+  bus.mmio[0xff4d] = this;  //KEY1
+  bus.mmio[0xff51] = this;  //HDMA1
+  bus.mmio[0xff52] = this;  //HDMA2
+  bus.mmio[0xff53] = this;  //HDMA3
+  bus.mmio[0xff54] = this;  //HDMA4
+  bus.mmio[0xff55] = this;  //HDMA5
+  bus.mmio[0xff56] = this;  //RP
+  bus.mmio[0xff6c] = this;  //???
+  bus.mmio[0xff70] = this;  //SVBK
+  bus.mmio[0xff72] = this;  //???
+  bus.mmio[0xff73] = this;  //???
+  bus.mmio[0xff74] = this;  //???
+  bus.mmio[0xff75] = this;  //???
+  bus.mmio[0xff76] = this;  //???
+  bus.mmio[0xff77] = this;  //???
+  }
+
+  for(auto &n : wram) n = 0x00;
+  for(auto &n : hram) n = 0x00;
 
   r[PC] = 0x0000;
   r[SP] = 0x0000;
@@ -143,6 +171,23 @@ void CPU::power() {
   status.interrupt_request_stat = 0;
   status.interrupt_request_vblank = 0;
 
+  status.speed_double = 0;
+  status.speed_switch = 0;
+
+  status.dma_source = 0;
+  status.dma_target = 0;
+
+  status.dma_mode = 0;
+  status.dma_length = 0;
+
+  status.ff6c = 0;
+  status.ff72 = 0;
+  status.ff73 = 0;
+  status.ff74 = 0;
+  status.ff75 = 0;
+
+  status.wram_bank = 1;
+
   status.interrupt_enable_joypad = 0;
   status.interrupt_enable_serial = 0;
   status.interrupt_enable_timer = 0;

bsnes/gameboy/cpu/cpu.hpp

@@ -54,6 +54,32 @@ struct CPU : Processor, MMIO {
     bool interrupt_request_stat;
     bool interrupt_request_vblank;
 
+    //$ff4d  KEY1
+    bool speed_double;
+    bool speed_switch;
+
+    //$ff51,$ff52  HDMA1,HDMA2
+    uint16 dma_source;
+
+    //$ff53,$ff54  HDMA3,HDMA4
+    uint16 dma_target;
+
+    //$ff55  HDMA5
+    bool dma_mode;
+    uint16 dma_length;
+
+    //$ff6c  ???
+    uint8 ff6c;
+
+    //$ff70  SVBK
+    uint3 wram_bank;
+
+    //$ff72-$ff75  ???
+    uint8 ff72;
+    uint8 ff73;
+    uint8 ff74;
+    uint8 ff75;
+
     //$ffff  IE
     bool interrupt_enable_joypad;
     bool interrupt_enable_serial;
@@ -62,7 +88,7 @@ struct CPU : Processor, MMIO {
     bool interrupt_enable_vblank;
   } status;
 
-  uint8 wram[8192];
+  uint8 wram[32768];  //GB=8192, GBC=32768
   uint8 hram[128];
 
   static void Main();

bsnes/gameboy/cpu/mmio/mmio.cpp

@@ -1,5 +1,12 @@
 #ifdef CPU_CPP
 
+unsigned CPU::wram_addr(uint16 addr) const {
+  addr &= 0x1fff;
+  if(addr < 0x1000) return addr;
+  auto bank = status.wram_bank + (status.wram_bank == 0);
+  return (bank * 0x1000) + (addr & 0x0fff);
+}
+
 void CPU::mmio_joyp_poll() {
   unsigned button = 0, dpad = 0;
 
@@ -21,8 +28,7 @@ void CPU::mmio_joyp_poll() {
 }
 
 uint8 CPU::mmio_read(uint16 addr) {
-  if(addr >= 0xc000 && addr <= 0xdfff) return wram[addr & 0x1fff];
-  if(addr >= 0xe000 && addr <= 0xfdff) return wram[addr & 0x1fff];
+  if(addr >= 0xc000 && addr <= 0xfdff) return wram[wram_addr(addr)];
   if(addr >= 0xff80 && addr <= 0xfffe) return hram[addr & 0x7f];
 
   if(addr == 0xff00) {  //JOYP
@@ -65,6 +71,50 @@ uint8 CPU::mmio_read(uint16 addr) {
          | (status.interrupt_request_vblank << 0);
   }
 
+  if(addr == 0xff4d) {  //KEY1
+    return (status.speed_double << 7);
+  }
+
+  if(addr == 0xff55) {  //HDMA5
+    return (status.dma_length / 16) - 1;
+  }
+
+  if(addr == 0xff56) {  //RP
+    return 0x02;
+  }
+
+  if(addr == 0xff6c) {  //???
+    return 0xfe | status.ff6c;
+  }
+
+  if(addr == 0xff70) {  //SVBK
+    return status.wram_bank;
+  }
+
+  if(addr == 0xff72) {  //???
+    return status.ff72;
+  }
+
+  if(addr == 0xff73) {  //???
+    return status.ff73;
+  }
+
+  if(addr == 0xff74) {  //???
+    return status.ff74;
+  }
+
+  if(addr == 0xff75) {  //???
+    return 0x8f | status.ff75;
+  }
+
+  if(addr == 0xff76) {  //???
+    return 0x00;
+  }
+
+  if(addr == 0xff77) {  //???
+    return 0x00;
+  }
+
   if(addr == 0xffff) {  //IE
     return (status.interrupt_enable_joypad << 4)
          | (status.interrupt_enable_serial << 3)
@@ -77,8 +127,7 @@ uint8 CPU::mmio_read(uint16 addr) {
 }
 
 void CPU::mmio_write(uint16 addr, uint8 data) {
-  if(addr >= 0xc000 && addr <= 0xdfff) { wram[addr & 0x1fff] = data; return; }
-  if(addr >= 0xe000 && addr <= 0xfdff) { wram[addr & 0x1fff] = data; return; }
+  if(addr >= 0xc000 && addr <= 0xfdff) { wram[wram_addr(addr)] = data; return; }
   if(addr >= 0xff80 && addr <= 0xfffe) { hram[addr & 0x7f] = data; return; }
 
   if(addr == 0xff00) {  //JOYP
@@ -131,6 +180,84 @@ void CPU::mmio_write(uint16 addr, uint8 data) {
     return;
   }
 
+  if(addr == 0xff46) {  //DMA
+    for(unsigned n = 0x00; n <= 0x9f; n++) {
+      bus.write(0xfe00 + n, bus.read((data << 8) + n));
+      add_clocks(4);
+    }
+    return;
+  }
+
+  if(addr == 0xff4d) {  //KEY1
+    status.speed_switch = data & 0x01;
+    return;
+  }
+
+  if(addr == 0xff51) {  //HDMA1
+    status.dma_source = (status.dma_source & 0x00ff) | (data << 8);
+    return;
+  }
+
+  if(addr == 0xff52) {  //HDMA2
+    status.dma_source = (status.dma_source & 0xff00) | (data << 0);
+    return;
+  }
+
+  if(addr == 0xff53) {  //HDMA3
+    status.dma_target = (status.dma_target & 0x00ff) | (data << 8);
+    return;
+  }
+
+  if(addr == 0xff54) {  //HDMA4
+    status.dma_target = (status.dma_target & 0xff00) | (data << 0);
+    return;
+  }
+
+  if(addr == 0xff55) {  //HDMA5
+    status.dma_mode = data & 0x80;
+    status.dma_length = ((data & 0x7f) + 1) * 16;
+
+    if(status.dma_mode == 0) do {
+      bus.write(status.dma_target++, bus.read(status.dma_source++));
+      add_clocks(4 << status.speed_double);
+    } while(--status.dma_length);
+    return;
+  }
+
+  if(addr == 0xff56) {  //RP
+    return;
+  }
+
+  if(addr == 0xff6c) {  //???
+    status.ff6c = data & 0x01;
+    return;
+  }
+
+  if(addr == 0xff72) {  //???
+    status.ff72 = data;
+    return;
+  }
+
+  if(addr == 0xff73) {  //???
+    status.ff73 = data;
+    return;
+  }
+
+  if(addr == 0xff74) {  //???
+    status.ff74 = data;
+    return;
+  }
+
+  if(addr == 0xff75) {  //???
+    status.ff75 = data & 0x70;
+    return;
+  }
+
+  if(addr == 0xff70) {  //SVBK
+    status.wram_bank = data & 0x07;
+    return;
+  }
+
   if(addr == 0xffff) {  //IE
     status.interrupt_enable_joypad = data & 0x10;
     status.interrupt_enable_serial = data & 0x08;

bsnes/gameboy/cpu/mmio/mmio.hpp

@@ -1,3 +1,4 @@
+unsigned wram_addr(uint16 addr) const;
 void mmio_joyp_poll();
 uint8 mmio_read(uint16 addr);
 void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/cpu/serialization.cpp

@@ -1,6 +1,8 @@
 #ifdef CPU_CPP
 
 void CPU::serialize(serializer &s) {
+  Processor::serialize(s);
+
   s.array(wram);
   s.array(hram);
 
@@ -47,6 +49,23 @@ void CPU::serialize(serializer &s) {
   s.integer(status.interrupt_request_stat);
   s.integer(status.interrupt_request_vblank);
 
+  s.integer(status.speed_double);
+  s.integer(status.speed_switch);
+
+  s.integer(status.dma_source);
+  s.integer(status.dma_target);
+  s.integer(status.dma_mode);
+  s.integer(status.dma_length);
+
+  s.integer(status.ff6c);
+
+  s.integer(status.wram_bank);
+
+  s.integer(status.ff72);
+  s.integer(status.ff73);
+  s.integer(status.ff74);
+  s.integer(status.ff75);
+
   s.integer(status.interrupt_enable_joypad);
   s.integer(status.interrupt_enable_serial);
   s.integer(status.interrupt_enable_timer);

bsnes/gameboy/cpu/timing/timing.cpp

@@ -1,5 +1,3 @@
-//4194304hz (4 * 1024 * 1024)
-
 //70224 clocks/frame
 //  456 clocks/scanline
 //  154 scanlines/frame
@@ -10,25 +8,25 @@
 
 void CPU::add_clocks(unsigned clocks) {
   system.clocks_executed += clocks;
-  scheduler.exit(Scheduler::ExitReason::StepEvent);
+  if(system.sgb()) scheduler.exit(Scheduler::ExitReason::StepEvent);
 
   status.clock += clocks;
-  if(status.clock >= 4194304) {
-    status.clock -= 4194304;
+  if(status.clock >= 4 * 1024 * 1024) {
+    status.clock -= 4 * 1024 * 1024;
     cartridge.mbc3.second();
   }
 
-  //4194304 / N(hz) - 1 = mask
+  //4MHz / N(hz) - 1 = mask
   if((status.clock &   15) == 0) timer_262144hz();
   if((status.clock &   63) == 0)  timer_65536hz();
   if((status.clock &  255) == 0)  timer_16384hz();
   if((status.clock &  511) == 0)   timer_8192hz();
   if((status.clock & 1023) == 0)   timer_4096hz();
 
-  lcd.clock -= clocks;
+  lcd.clock -= clocks * lcd.frequency;
   if(lcd.clock <= 0) co_switch(scheduler.active_thread = lcd.thread);
 
-  apu.clock -= clocks;
+  apu.clock -= clocks * apu.frequency;
   if(apu.clock <= 0) co_switch(scheduler.active_thread = apu.thread);
 }
 
@@ -79,4 +77,14 @@ void CPU::timer_4096hz() {
   }
 }
 
+void CPU::hblank() {
+  if(status.dma_mode == 1 && status.dma_length) {
+    for(unsigned n = 0; n < 16; n++) {
+      bus.write(status.dma_target++, bus.read(status.dma_source++));
+      add_clocks(4);
+    }
+    status.dma_length -= 16;
+  }
+}
+
 #endif

bsnes/gameboy/cpu/timing/timing.hpp

@@ -4,6 +4,7 @@ void timer_65536hz();
 void timer_16384hz();
 void timer_8192hz();
 void timer_4096hz();
+void hblank();
 
 //opcode.cpp
 void op_io();

bsnes/gameboy/gameboy.hpp

@@ -4,12 +4,12 @@
 namespace GameBoy {
   namespace Info {
     static const char Name[] = "bgameboy";
-    static const unsigned SerializerVersion = 2;
+    static const unsigned SerializerVersion = 3;
   }
 }
 
 /*
-  bgameboy - Game Boy emulator
+  bgameboy - Game Boy, Super Game Boy, and Game Boy Color emulator
   author: byuu
   license: GPLv3
   project started: 2010-12-27
@@ -69,25 +69,29 @@ namespace GameBoy {
   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;
     int64 clock;
 
-    inline void create(void (*entrypoint_)(), unsigned frequency_) {
+    inline void create(void (*entrypoint)(), unsigned frequency) {
       if(thread) co_delete(thread);
-      thread = co_create(65536 * sizeof(void*), entrypoint_);
-      frequency = frequency_;
+      thread = co_create(65536 * sizeof(void*), entrypoint);
+      this->frequency = frequency;
       clock = 0;
     }
 
-    inline Processor() : thread(nullptr) {}
+    inline void serialize(serializer &s) {
+      s.integer(frequency);
+      s.integer(clock);
+    }
+
+    inline Processor() : thread(nullptr) {
+    }
+
+    inline ~Processor() {
+      if(thread) co_delete(thread);
+    }
   };
 
   #include <gameboy/memory/memory.hpp>
@@ -98,6 +102,7 @@ namespace GameBoy {
   #include <gameboy/apu/apu.hpp>
   #include <gameboy/lcd/lcd.hpp>
   #include <gameboy/cheat/cheat.hpp>
+  #include <gameboy/video/video.hpp>
 };
 
 #endif

bsnes/gameboy/interface/interface.cpp

@@ -2,7 +2,7 @@
 
 namespace GameBoy {
 
-Interface *interface = 0;
+Interface *interface = nullptr;
 
 void Interface::lcdScanline() {
 }
@@ -10,7 +10,7 @@ void Interface::lcdScanline() {
 void Interface::joypWrite(bool p15, bool p14) {
 }
 
-void Interface::videoRefresh(const uint8_t *data) {
+void Interface::videoRefresh(const uint16_t *data) {
 }
 
 void Interface::audioSample(int16_t center, int16_t left, int16_t right) {
@@ -20,68 +20,6 @@ bool Interface::inputPoll(unsigned id) {
   return false;
 }
 
-void Interface::initialize(Interface *derived_interface) {
-  interface = derived_interface;
-  system.init();
-}
-
-bool Interface::cartridgeLoaded() {
-  return cartridge.loaded();
-}
-
-void Interface::loadCartridge(const string &markup, const uint8_t *data, unsigned size) {
-  cartridge.load(markup, data, size);
-  system.power();
-}
-
-void Interface::unloadCartridge() {
-  cartridge.unload();
-}
-
-unsigned Interface::memorySize(Memory memory) {
-  if(memory == Memory::RAM) return cartridge.ramsize;
-  return 0u;
-}
-
-uint8_t* Interface::memoryData(Memory memory) {
-  if(memory == Memory::RAM) return cartridge.ramdata;
-  return 0u;
-}
-
-void Interface::power() {
-  system.power();
-}
-
-void Interface::run() {
-  do {
-    system.run();
-  } while(scheduler.exit_reason() != Scheduler::ExitReason::FrameEvent);
-}
-
-serializer Interface::serialize() {
-  system.runtosave();
-  return system.serialize();
-}
-
-bool Interface::unserialize(serializer &s) {
-  return system.unserialize(s);
-}
-
-void Interface::setCheats(const lstring &list) {
-  cheat.reset();
-  for(auto &code : list) {
-    lstring codelist;
-    codelist.split("+", code);
-    for(auto &part : codelist) {
-      unsigned addr, data, comp;
-      if(Cheat::decode(part, addr, data, comp)) {
-        cheat.append({ addr, data, comp });
-      }
-    }
-  }
-  cheat.synchronize();
-}
-
 void Interface::message(const string &text) {
   print(text, "\n");
 }

bsnes/gameboy/interface/interface.hpp

@@ -1,33 +1,11 @@
-class Interface {
-public:
+struct Interface {
   virtual void lcdScanline();
   virtual void joypWrite(bool p15, bool p14);
 
-  virtual void videoRefresh(const uint8_t *data);
+  virtual void videoRefresh(const uint16_t *data);
   virtual void audioSample(int16_t center, int16_t left, int16_t right);
   virtual bool inputPoll(unsigned id);
 
-  virtual void initialize(Interface*);
-
-  virtual bool cartridgeLoaded();
-  virtual void loadCartridge(const string &markup, const uint8_t *data, unsigned size);
-  virtual void unloadCartridge();
-
-  enum class Memory : unsigned {
-    RAM,
-  };
-
-  virtual unsigned memorySize(Memory);
-  virtual uint8_t* memoryData(Memory);
-
-  virtual void power();
-  virtual void run();
-
-  virtual serializer serialize();
-  virtual bool unserialize(serializer&);
-
-  virtual void setCheats(const lstring &list = lstring{});
-
   virtual void message(const string &text);
 };
 

bsnes/gameboy/lcd/cgb.cpp

@@ -0,0 +1,185 @@
+#ifdef LCD_CPP
+
+void LCD::cgb_render() {
+  for(unsigned n = 0; n < 160; n++) {
+    line[n] = 0x7fff;
+    origin[n] = Origin::None;
+  }
+
+  if(status.display_enable) {
+    cgb_render_bg();
+    if(status.window_display_enable) cgb_render_window();
+    if(status.ob_enable) cgb_render_ob();
+  }
+
+  uint16 *output = screen + status.ly * 160;
+  for(unsigned n = 0; n < 160; n++) output[n] = line[n];
+  interface->lcdScanline();
+}
+
+//Attributes:
+//0x80: 0 = OAM priority, 1 = BG priority
+//0x40: vertical flip
+//0x20: horizontal flip
+//0x08: VRAM bank#
+//0x07: palette#
+void LCD::cgb_read_tile(bool select, unsigned x, unsigned y, unsigned &tile, unsigned &attr, unsigned &data) {
+  unsigned tmaddr = 0x1800 + (select << 10);
+  tmaddr += (((y >> 3) << 5) + (x >> 3)) & 0x03ff;
+
+  tile = vram[0x0000 + tmaddr];
+  attr = vram[0x2000 + tmaddr];
+
+  unsigned tdaddr = attr & 0x08 ? 0x2000 : 0x0000;
+  if(status.bg_tiledata_select == 0) {
+    tdaddr += 0x1000 + ((int8)tile << 4);
+  } else {
+    tdaddr += 0x0000 + (tile << 4);
+  }
+
+  y &= 7;
+  if(attr & 0x40) y ^= 7;
+  tdaddr += y << 1;
+
+  data  = vram[tdaddr++] << 0;
+  data |= vram[tdaddr++] << 8;
+  if(attr & 0x20) data = hflip(data);
+}
+
+void LCD::cgb_render_bg() {
+  unsigned iy = (status.ly + status.scy) & 255;
+  unsigned ix = status.scx, tx = ix & 7;
+
+  unsigned tile, attr, data;
+  cgb_read_tile(status.bg_tilemap_select, ix, iy, tile, attr, data);
+
+  for(unsigned ox = 0; ox < 160; ox++) {
+    unsigned index = ((data & (0x0080 >> tx)) ? 1 : 0)
+                   | ((data & (0x8000 >> tx)) ? 2 : 0);
+    unsigned palette_index = ((attr & 0x07) << 3) + (index << 1);
+    unsigned palette = 0;
+    palette |= bgpd[palette_index++] << 0;
+    palette |= bgpd[palette_index++] << 8;
+    palette &= 0x7fff;
+
+    line[ox] = palette;
+    origin[ox] = (attr & 0x80 ? Origin::BGP : Origin::BG);
+
+    ix = (ix + 1) & 255;
+    tx = (tx + 1) & 7;
+    if(tx == 0) cgb_read_tile(status.bg_tilemap_select, ix, iy, tile, attr, data);
+  }
+}
+
+void LCD::cgb_render_window() {
+  if(status.ly - status.wy >= 144u) return;
+  if(status.wx >= 167u) return;
+  unsigned iy = status.wyc++;
+  unsigned ix = (7 - status.wx) & 255, tx = ix & 7;
+
+  unsigned tile, attr, data;
+  cgb_read_tile(status.window_tilemap_select, ix, iy, tile, attr, data);
+
+  for(unsigned ox = 0; ox < 160; ox++) {
+    unsigned index = ((data & (0x0080 >> tx)) ? 1 : 0)
+                   | ((data & (0x8000 >> tx)) ? 2 : 0);
+    unsigned palette_index = ((attr & 0x07) << 3) + (index << 1);
+    unsigned palette = 0;
+    palette |= bgpd[palette_index++] << 0;
+    palette |= bgpd[palette_index++] << 8;
+    palette &= 0x7fff;
+
+    if(ox - (status.wx - 7) < 160u) {
+      line[ox] = palette;
+      origin[ox] = (attr & 0x80 ? Origin::BGP : Origin::BG);
+    }
+
+    ix = (ix + 1) & 255;
+    tx = (tx + 1) & 7;
+    if(tx == 0) cgb_read_tile(status.window_tilemap_select, ix, iy, tile, attr, data);
+  }
+}
+
+//Attributes:
+//0x80: 0 = OBJ above BG, 1 = BG above OBJ
+//0x40: vertical flip
+//0x20: horizontal flip
+//0x08: VRAM bank#
+//0x07: palette#
+void LCD::cgb_render_ob() {
+  const unsigned Height = (status.ob_size == 0 ? 8 : 16);
+  unsigned sprite[10], sprites = 0;
+
+  //find first ten sprites on this scanline
+  for(unsigned s = 0; s < 40; s++) {
+    unsigned sy = oam[(s << 2) + 0] - 16;
+    unsigned sx = oam[(s << 2) + 1] -  8;
+
+    sy = status.ly - sy;
+    if(sy >= Height) continue;
+
+    sprite[sprites++] = s;
+    if(sprites == 10) break;
+  }
+
+  //sort by X-coordinate, when equal, lower address comes first
+  for(unsigned x = 0; x < sprites; x++) {
+    for(unsigned y = x + 1; y < sprites; y++) {
+      signed sx = oam[(sprite[x] << 2) + 1] - 8;
+      signed sy = oam[(sprite[y] << 2) + 1] - 8;
+      if(sy < sx) {
+        sprite[x] ^= sprite[y];
+        sprite[y] ^= sprite[x];
+        sprite[x] ^= sprite[y];
+      }
+    }
+  }
+
+  //render backwards, so that first sprite has highest priority
+  for(signed s = sprites - 1; s >= 0; s--) {
+    unsigned n = sprite[s] << 2;
+    unsigned sy = oam[n + 0] - 16;
+    unsigned sx = oam[n + 1] -  8;
+    unsigned tile = oam[n + 2] & ~status.ob_size;
+    unsigned attr = oam[n + 3];
+
+    sy = status.ly - sy;
+    if(sy >= Height) continue;
+    if(attr & 0x40) sy ^= (Height - 1);
+
+    unsigned tdaddr = (attr & 0x08 ? 0x2000 : 0x0000) + (tile << 4) + (sy << 1), data = 0;
+    data |= vram[tdaddr++] << 0;
+    data |= vram[tdaddr++] << 8;
+    if(attr & 0x20) data = hflip(data);
+
+    for(unsigned tx = 0; tx < 8; tx++) {
+      unsigned index = ((data & (0x0080 >> tx)) ? 1 : 0)
+                     | ((data & (0x8000 >> tx)) ? 2 : 0);
+      if(index == 0) continue;
+
+      unsigned palette_index = ((attr & 0x07) << 3) + (index << 1);
+      unsigned palette = 0;
+      palette |= obpd[palette_index++] << 0;
+      palette |= obpd[palette_index++] << 8;
+      palette &= 0x7fff;
+
+      unsigned ox = sx + tx;
+
+      if(ox < 160) {
+        //When LCDC.D0 (BG enable) is off, OB is always rendered above BG+Window
+        if(status.bg_enable) {
+          if(origin[ox] == Origin::BGP) continue;
+          if(attr & 0x80) {
+            if(origin[ox] == Origin::BG || origin[ox] == Origin::BGP) {
+              if(line[ox] > 0) continue;
+            }
+          }
+        }
+        line[ox] = palette;
+        origin[ox] = Origin::OB;
+      }
+    }
+  }
+}
+
+#endif

bsnes/gameboy/lcd/dmg.cpp

@@ -0,0 +1,145 @@
+#ifdef LCD_CPP
+
+void LCD::dmg_render() {
+  for(unsigned n = 0; n < 160; n++) {
+    line[n] = 0x00;
+    origin[n] = Origin::None;
+  }
+
+  if(status.display_enable) {
+    if(status.bg_enable) dmg_render_bg();
+    if(status.window_display_enable) dmg_render_window();
+    if(status.ob_enable) dmg_render_ob();
+  }
+
+  uint16 *output = screen + status.ly * 160;
+  for(unsigned n = 0; n < 160; n++) output[n] = line[n];
+  interface->lcdScanline();
+}
+
+uint16 LCD::dmg_read_tile(bool select, unsigned x, unsigned y) {
+  unsigned tmaddr = 0x1800 + (select << 10), tdaddr;
+  tmaddr += (((y >> 3) << 5) + (x >> 3)) & 0x03ff;
+  if(status.bg_tiledata_select == 0) {
+    tdaddr = 0x1000 + ((int8)vram[tmaddr] << 4);
+  } else {
+    tdaddr = 0x0000 + (vram[tmaddr] << 4);
+  }
+  tdaddr += (y & 7) << 1;
+  return (vram[tdaddr + 0] << 0) | (vram[tdaddr + 1] << 8);
+}
+
+void LCD::dmg_render_bg() {
+  unsigned iy = (status.ly + status.scy) & 255;
+  unsigned ix = status.scx, tx = ix & 7;
+  unsigned data = dmg_read_tile(status.bg_tilemap_select, ix, iy);
+
+  for(unsigned ox = 0; ox < 160; ox++) {
+    uint8 palette = ((data & (0x0080 >> tx)) ? 1 : 0)
+                  | ((data & (0x8000 >> tx)) ? 2 : 0);
+
+    line[ox] = bgp[palette];
+    origin[ox] = Origin::BG;
+
+    ix = (ix + 1) & 255;
+    tx = (tx + 1) & 7;
+
+    if(tx == 0) data = dmg_read_tile(status.bg_tilemap_select, ix, iy);
+  }
+}
+
+void LCD::dmg_render_window() {
+  if(status.ly - status.wy >= 144u) return;
+  if(status.wx >= 167u) return;
+  unsigned iy = status.wyc++;
+  unsigned ix = (7 - status.wx) & 255, tx = ix & 7;
+  unsigned data = dmg_read_tile(status.window_tilemap_select, ix, iy);
+
+  for(unsigned ox = 0; ox < 160; ox++) {
+    uint8 palette = ((data & (0x0080 >> tx)) ? 1 : 0)
+                  | ((data & (0x8000 >> tx)) ? 2 : 0);
+    if(ox - (status.wx - 7) < 160u) {
+      line[ox] = bgp[palette];
+      origin[ox] = Origin::BG;
+    }
+
+    ix = (ix + 1) & 255;
+    tx = (tx + 1) & 7;
+
+    if(tx == 0) data = dmg_read_tile(status.window_tilemap_select, ix, iy);
+  }
+}
+
+//Attributes:
+//0x80: 0 = OBJ above BG, 1 = BG above OBJ
+//0x40: vertical flip
+//0x20: horizontal flip
+//0x10: palette#
+void LCD::dmg_render_ob() {
+  const unsigned Height = (status.ob_size == 0 ? 8 : 16);
+  unsigned sprite[10], sprites = 0;
+
+  //find first ten sprites on this scanline
+  for(unsigned s = 0; s < 40; s++) {
+    unsigned sy = oam[(s << 2) + 0] - 16;
+    unsigned sx = oam[(s << 2) + 1] -  8;
+
+    sy = status.ly - sy;
+    if(sy >= Height) continue;
+
+    sprite[sprites++] = s;
+    if(sprites == 10) break;
+  }
+
+  //sort by X-coordinate, when equal, lower address comes first
+  for(unsigned x = 0; x < sprites; x++) {
+    for(unsigned y = x + 1; y < sprites; y++) {
+      signed sx = oam[(sprite[x] << 2) + 1] - 8;
+      signed sy = oam[(sprite[y] << 2) + 1] - 8;
+      if(sy < sx) {
+        sprite[x] ^= sprite[y];
+        sprite[y] ^= sprite[x];
+        sprite[x] ^= sprite[y];
+      }
+    }
+  }
+
+  //render backwards, so that first sprite has highest priority
+  for(signed s = sprites - 1; s >= 0; s--) {
+    unsigned n = sprite[s] << 2;
+    unsigned sy = oam[n + 0] - 16;
+    unsigned sx = oam[n + 1] -  8;
+    unsigned tile = oam[n + 2] & ~status.ob_size;
+    unsigned attr = oam[n + 3];
+
+    sy = status.ly - sy;
+    if(sy >= Height) continue;
+    if(attr & 0x40) sy ^= (Height - 1);
+
+    unsigned tdaddr = (tile << 4) + (sy << 1), data = 0;
+    data |= vram[tdaddr++] << 0;
+    data |= vram[tdaddr++] << 8;
+    if(attr & 0x20) data = hflip(data);
+
+    for(unsigned tx = 0; tx < 8; tx++) {
+      uint8 palette = ((data & (0x0080 >> tx)) ? 1 : 0)
+                    | ((data & (0x8000 >> tx)) ? 2 : 0);
+      if(palette == 0) continue;
+
+      palette = obp[(bool)(attr & 0x10)][palette];
+      unsigned ox = sx + tx;
+
+      if(ox < 160) {
+        if(attr & 0x80) {
+          if(origin[ox] == Origin::BG) {
+            if(line[ox] > 0) continue;
+          }
+        }
+        line[ox] = palette;
+        origin[ox] = Origin::OB;
+      }
+    }
+  }
+}
+
+#endif

bsnes/gameboy/lcd/lcd.cpp

@@ -1,14 +1,20 @@
 #include <gameboy/gameboy.hpp>
 
+//LY     =   0-153
+//Raster =   0-143
+//Vblank = 144-153
+
+//LX     =   0-455
+
 #define LCD_CPP
 namespace GameBoy {
 
+#include "dmg.cpp"
+#include "cgb.cpp"
 #include "mmio/mmio.cpp"
 #include "serialization.cpp"
 LCD lcd;
 
-static unsigned linectr;
-
 void LCD::Main() {
   lcd.main();
 }
@@ -29,12 +35,13 @@ void LCD::main() {
 
     if(status.display_enable && status.lx == 252) {
       if(status.interrupt_hblank) cpu.interrupt_raise(CPU::Interrupt::Stat);
+      cpu.hblank();
     }
   }
 }
 
 void LCD::add_clocks(unsigned clocks) {
-  clock += clocks;
+  clock += clocks * cpu.frequency;
   if(clock >= 0 && scheduler.sync != Scheduler::SynchronizeMode::All) {
     co_switch(scheduler.active_thread = cpu.thread);
   }
@@ -48,7 +55,9 @@ void LCD::scanline() {
     if(status.ly == status.lyc) cpu.interrupt_raise(CPU::Interrupt::Stat);
   }
 
-  if(status.ly < 144) render();
+  if(status.ly < 144) {
+    system.cgb() == false ? dmg_render() : cgb_render();
+  }
 
   if(status.display_enable && status.ly == 144) {
     cpu.interrupt_raise(CPU::Interrupt::Vblank);
@@ -65,157 +74,50 @@ void LCD::frame() {
   scheduler.exit(Scheduler::ExitReason::FrameEvent);
 }
 
-void LCD::render() {
-  for(unsigned n = 0; n < 160; n++) {
-    line[n] = 0x00;
-    origin[n] = Origin::None;
-  }
-
-  if(status.display_enable == true) {
-    if(status.bg_enable == true) render_bg();
-    if(status.window_display_enable == true) render_window();
-    if(status.obj_enable == true) render_obj();
-  }
-
-  uint8_t *output = screen + status.ly * 160;
-  for(unsigned n = 0; n < 160; n++) output[n] = line[n];
-  interface->lcdScanline();
-}
-
-uint16 LCD::read_tile(bool select, unsigned x, unsigned y) {
-  unsigned tmaddr = 0x1800 + (select << 10), tdaddr;
-  tmaddr += (((y >> 3) << 5) + (x >> 3)) & 0x03ff;
-  if(status.bg_tiledata_select == 0) {
-    tdaddr = 0x1000 + ((int8)vram[tmaddr] << 4);
-  } else {
-    tdaddr = 0x0000 + (vram[tmaddr] << 4);
-  }
-  tdaddr += (y & 7) << 1;
-  return (vram[tdaddr + 0] << 0) | (vram[tdaddr + 1] << 8);
-}
-
-void LCD::render_bg() {
-  unsigned iy = (status.ly + status.scy) & 255;
-  unsigned ix = status.scx, tx = ix & 7;
-  unsigned data = read_tile(status.bg_tilemap_select, ix, iy);
-
-  for(unsigned ox = 0; ox < 160; ox++) {
-    uint8 palette = ((data & (0x0080 >> tx)) ? 1 : 0)
-                  | ((data & (0x8000 >> tx)) ? 2 : 0);
-
-    line[ox] = status.bgp[palette];
-    origin[ox] = Origin::BG;
-
-    ix = (ix + 1) & 255;
-    tx = (tx + 1) & 7;
-
-    if(tx == 0) data = read_tile(status.bg_tilemap_select, ix, iy);
-  }
-}
-
-void LCD::render_window() {
-  if(status.ly - status.wy >= 144u) return;
-  if(status.wx >= 167u) return;
-  unsigned iy = status.wyc++;
-  unsigned ix = (7 - status.wx) & 255, tx = ix & 7;
-  unsigned data = read_tile(status.window_tilemap_select, ix, iy);
-
-  for(unsigned ox = 0; ox < 160; ox++) {
-    uint8 palette = ((data & (0x0080 >> tx)) ? 1 : 0)
-                  | ((data & (0x8000 >> tx)) ? 2 : 0);
-    if(ox - (status.wx - 7) < 160U) {
-      line[ox] = status.bgp[palette];
-      origin[ox] = Origin::Window;
-    }
-
-    ix = (ix + 1) & 255;
-    tx = (tx + 1) & 7;
-
-    if(tx == 0) data = read_tile(status.window_tilemap_select, ix, iy);
-  }
-}
-
-void LCD::render_obj() {
-  enum : unsigned { Priority = 0x80, YFlip = 0x40, XFlip = 0x20, Palette = 0x10 };
-
-  unsigned obj_size = (status.obj_size == 0 ? 8 : 16);
-
-  unsigned sprite[10], sprites = 0;
-
-  //find first ten sprites on this scanline
-  for(unsigned s = 0; s < 40; s++) {
-    unsigned sy = oam[(s << 2) + 0] - 16;
-    unsigned sx = oam[(s << 2) + 1] -  8;
-
-    sy = status.ly - sy;
-    if(sy >= obj_size) continue;
-
-    sprite[sprites++] = s;
-    if(sprites == 10) break;
-  }
-
-  //sort by X-coordinate, when equal, lower address comes first
-  for(unsigned x = 0; x < sprites; x++) {
-    for(unsigned y = x + 1; y < sprites; y++) {
-      signed sx = oam[(sprite[x] << 2) + 1] - 8;
-      signed sy = oam[(sprite[y] << 2) + 1] - 8;
-      if(sy < sx) {
-        sprite[x] ^= sprite[y];
-        sprite[y] ^= sprite[x];
-        sprite[x] ^= sprite[y];
-      }
-    }
-  }
-
-  //render backwards, so that first sprite has highest priority
-  for(signed s = sprites - 1; s >= 0; s--) {
-    unsigned n = sprite[s] << 2;
-    unsigned sy = oam[n + 0] - 16;
-    unsigned sx = oam[n + 1] -  8;
-    unsigned tile = oam[n + 2];
-    unsigned attribute = oam[n + 3];
-
-    sy = status.ly - sy;
-    if(sy >= obj_size) continue;
-    if(attribute & YFlip) sy ^= (obj_size - 1);
-
-    unsigned tdaddr = (tile << 4) + (sy << 1);
-    uint8 d0 = vram[tdaddr + 0];
-    uint8 d1 = vram[tdaddr + 1];
-    unsigned xflip = attribute & XFlip ? 7 : 0;
-
-    for(unsigned tx = 0; tx < 8; tx++) {
-      uint8 palette = ((d0 & (0x80 >> tx)) ? 1 : 0)
-                    | ((d1 & (0x80 >> tx)) ? 2 : 0);
-      if(palette == 0) continue;
-
-      palette = status.obp[(bool)(attribute & Palette)][palette];
-      unsigned ox = sx + (tx ^ xflip);
-
-      if(ox <= 159) {
-        if(attribute & Priority) {
-          if(origin[ox] == Origin::BG || origin[ox] == Origin::Window) {
-            if(line[ox] > 0) continue;
-          }
-        }
-        line[ox] = palette;
-        origin[ox] = Origin::OBJ;
-      }
-    }
-  }
+unsigned LCD::hflip(unsigned data) const {
+  return ((data & 0x8080) >> 7) | ((data & 0x4040) >> 5)
+       | ((data & 0x2020) >> 3) | ((data & 0x1010) >> 1)
+       | ((data & 0x0808) << 1) | ((data & 0x0404) << 3)
+       | ((data & 0x0202) << 5) | ((data & 0x0101) << 7);
 }
 
 void LCD::power() {
-  create(Main, 4194304);
+  create(Main, 4 * 1024 * 1024);
 
   for(unsigned n = 0x8000; n <= 0x9fff; n++) bus.mmio[n] = this;  //VRAM
-  for(unsigned n = 0xff40; n <= 0xff4b; n++) bus.mmio[n] = this;  //MMIO
   for(unsigned n = 0xfe00; n <= 0xfe9f; n++) bus.mmio[n] = this;  //OAM
 
-  for(unsigned n = 0; n < 8192; n++) vram[n] = 0x00;
-  for(unsigned n = 0; n <  160; n++) oam [n] = 0x00;
+  bus.mmio[0xff40] = this;  //LCDC
+  bus.mmio[0xff41] = this;  //STAT
+  bus.mmio[0xff42] = this;  //SCY
+  bus.mmio[0xff43] = this;  //SCX
+  bus.mmio[0xff44] = this;  //LY
+  bus.mmio[0xff45] = this;  //LYC
+  bus.mmio[0xff47] = this;  //BGP
+  bus.mmio[0xff48] = this;  //OBP0
+  bus.mmio[0xff49] = this;  //OBP1
+  bus.mmio[0xff4a] = this;  //WY
+  bus.mmio[0xff4b] = this;  //WX
 
-  for(unsigned n = 0; n < 160 * 144; n++) screen[n] = 0x00;
+  if(system.cgb()) {
+  bus.mmio[0xff4f] = this;  //VBK
+  bus.mmio[0xff68] = this;  //BGPI
+  bus.mmio[0xff69] = this;  //BGPD
+  bus.mmio[0xff6a] = this;  //OBPI
+  bus.mmio[0xff6b] = this;  //OBPD
+  }
+
+  for(auto &n : screen) n = 0x0000;
+  for(auto &n : line) n = 0x0000;
+  for(auto &n : origin) n = Origin::None;
+
+  for(auto &n : vram) n = 0x00;
+  for(auto &n : oam) n = 0x00;
+  for(auto &n : bgp) n = 0x00;
+  for(auto &n : obp[0]) n = 0x00;
+  for(auto &n : obp[1]) n = 0x00;
+  for(auto &n : bgpd) n = 0x0000;
+  for(auto &n : obpd) n = 0x0000;
 
   status.lx = 0;
   status.wyc = 0;
@@ -225,8 +127,8 @@ void LCD::power() {
   status.window_display_enable = 0;
   status.bg_tiledata_select = 0;
   status.bg_tilemap_select = 0;
-  status.obj_size = 0;
-  status.obj_enable = 0;
+  status.ob_size = 0;
+  status.ob_enable = 0;
   status.bg_enable = 0;
 
   status.interrupt_lyc = 0;
@@ -238,15 +140,16 @@ void LCD::power() {
   status.scx = 0;
   status.ly = 0;
   status.lyc = 0;
-
-  for(unsigned n = 0; n < 4; n++) {
-    status.bgp[n] = n;
-    status.obp[0][n] = n;
-    status.obp[1][n] = n;
-  }
-
   status.wy = 0;
   status.wx = 0;
+
+  status.vram_bank = 0;
+
+  status.bgpi_increment = 0;
+  status.bgpi = 0;
+
+  status.obpi_increment = 0;
+  status.obpi = 0;
 }
 
 LCD::LCD() {

bsnes/gameboy/lcd/lcd.hpp

@@ -11,8 +11,8 @@ struct LCD : Processor, MMIO {
     bool window_display_enable;
     bool bg_tiledata_select;
     bool bg_tilemap_select;
-    bool obj_size;
-    bool obj_enable;
+    bool ob_size;
+    bool ob_enable;
     bool bg_enable;
 
     //$ff41  STAT
@@ -33,38 +33,57 @@ struct LCD : Processor, MMIO {
     //$ff45  LYC
     uint8 lyc;
 
-    //$ff47  BGP
-    uint8 bgp[4];
-
-    //$ff48  OBP0
-    //$ff49  OBP1
-    uint8 obp[2][4];
-
     //$ff4a  WY
     uint8 wy;
 
     //$ff4b  WX
     uint8 wx;
+
+    //$ff4f  VBK
+    bool vram_bank;
+
+    //$ff68  BGPI
+    bool bgpi_increment;
+    uint6 bgpi;
+
+    //$ff6a  OBPI
+    bool obpi_increment;
+    uint8 obpi;
   } status;
 
-  uint8 screen[160 * 144];
-  uint8 vram[8192];
-  uint8 oam[160];
-  uint8 line[160];
-
-  struct Origin { enum : unsigned { None, BG, Window, OBJ }; };
+  uint16 screen[160 * 144];
+  uint16 line[160];
+  struct Origin { enum : unsigned { None, BG, BGP, OB }; };
   uint8 origin[160];
 
+  uint8 vram[16384];  //GB = 8192, GBC = 16384
+  uint8 oam[160];
+  uint8 bgp[4];
+  uint8 obp[2][4];
+  uint8 bgpd[64];
+  uint8 obpd[64];
+
   static void Main();
   void main();
   void add_clocks(unsigned clocks);
   void scanline();
   void frame();
-  void render();
-  uint16 read_tile(bool select, unsigned x, unsigned y);
-  void render_bg();
-  void render_window();
-  void render_obj();
+
+  unsigned hflip(unsigned data) const;
+
+  //dmg.cpp
+  void dmg_render();
+  uint16 dmg_read_tile(bool select, unsigned x, unsigned y);
+  void dmg_render_bg();
+  void dmg_render_window();
+  void dmg_render_ob();
+
+  //cgb.cpp
+  void cgb_render();
+  void cgb_read_tile(bool select, unsigned x, unsigned y, unsigned &tile, unsigned &attr, unsigned &data);
+  void cgb_render_bg();
+  void cgb_render_window();
+  void cgb_render_ob();
 
   void power();
 

bsnes/gameboy/lcd/mmio/mmio.cpp

@@ -1,7 +1,11 @@
 #ifdef LCD_CPP
 
+unsigned LCD::vram_addr(uint16 addr) const {
+  return (status.vram_bank * 0x2000) + (addr & 0x1fff);
+}
+
 uint8 LCD::mmio_read(uint16 addr) {
-  if(addr >= 0x8000 && addr <= 0x9fff) return vram[addr & 0x1fff];
+  if(addr >= 0x8000 && addr <= 0x9fff) return vram[vram_addr(addr)];
   if(addr >= 0xfe00 && addr <= 0xfe9f) return oam[addr & 0xff];
 
   if(addr == 0xff40) {  //LCDC
@@ -10,8 +14,8 @@ uint8 LCD::mmio_read(uint16 addr) {
          | (status.window_display_enable << 5)
          | (status.bg_tiledata_select << 4)
          | (status.bg_tilemap_select << 3)
-         | (status.obj_size << 2)
-         | (status.obj_enable << 1)
+         | (status.ob_size << 2)
+         | (status.ob_enable << 1)
          | (status.bg_enable << 0);
   }
 
@@ -47,24 +51,24 @@ uint8 LCD::mmio_read(uint16 addr) {
   }
 
   if(addr == 0xff47) {  //BGP
-    return (status.bgp[3] << 6)
-         | (status.bgp[2] << 4)
-         | (status.bgp[1] << 2)
-         | (status.bgp[0] << 0);
+    return (bgp[3] << 6)
+         | (bgp[2] << 4)
+         | (bgp[1] << 2)
+         | (bgp[0] << 0);
   }
 
   if(addr == 0xff48) {  //OBP0
-    return (status.obp[0][3] << 6)
-         | (status.obp[0][2] << 4)
-         | (status.obp[0][1] << 2)
-         | (status.obp[0][0] << 0);
+    return (obp[0][3] << 6)
+         | (obp[0][2] << 4)
+         | (obp[0][1] << 2)
+         | (obp[0][0] << 0);
   }
 
   if(addr == 0xff49) {  //OBP1
-    return (status.obp[1][3] << 6)
-         | (status.obp[1][2] << 4)
-         | (status.obp[1][1] << 2)
-         | (status.obp[1][0] << 0);
+    return (obp[1][3] << 6)
+         | (obp[1][2] << 4)
+         | (obp[1][1] << 2)
+         | (obp[1][0] << 0);
   }
 
   if(addr == 0xff4a) {  //WY
@@ -75,11 +79,19 @@ uint8 LCD::mmio_read(uint16 addr) {
     return status.wx;
   }
 
+  if(addr == 0xff69) { //BGPD
+    return bgpd[status.bgpi];
+  }
+
+  if(addr == 0xff6b) {  //OBPD
+    return obpd[status.obpi];
+  }
+
   return 0x00;
 }
 
 void LCD::mmio_write(uint16 addr, uint8 data) {
-  if(addr >= 0x8000 && addr <= 0x9fff) { vram[addr & 0x1fff] = data; return; }
+  if(addr >= 0x8000 && addr <= 0x9fff) { vram[vram_addr(addr)] = data; return; }
   if(addr >= 0xfe00 && addr <= 0xfe9f) { oam[addr & 0xff] = data; return; }
 
   if(addr == 0xff40) {  //LCDC
@@ -92,8 +104,8 @@ void LCD::mmio_write(uint16 addr, uint8 data) {
     status.window_display_enable = data & 0x20;
     status.bg_tiledata_select = data & 0x10;
     status.bg_tilemap_select = data & 0x08;
-    status.obj_size = data & 0x04;
-    status.obj_enable = data & 0x02;
+    status.ob_size = data & 0x04;
+    status.ob_enable = data & 0x02;
     status.bg_enable = data & 0x01;
     return;
   }
@@ -126,32 +138,27 @@ void LCD::mmio_write(uint16 addr, uint8 data) {
     return;
   }
 
-  if(addr == 0xff46) {  //DMA
-    for(unsigned n = 0x00; n <= 0x9f; n++) bus.write(0xfe00 + n, bus.read((data << 8) + n));
-    return;
-  }
-
   if(addr == 0xff47) {  //BGP
-    status.bgp[3] = (data >> 6) & 3;
-    status.bgp[2] = (data >> 4) & 3;
-    status.bgp[1] = (data >> 2) & 3;
-    status.bgp[0] = (data >> 0) & 3;
+    bgp[3] = (data >> 6) & 3;
+    bgp[2] = (data >> 4) & 3;
+    bgp[1] = (data >> 2) & 3;
+    bgp[0] = (data >> 0) & 3;
     return;
   }
 
   if(addr == 0xff48) {  //OBP0
-    status.obp[0][3] = (data >> 6) & 3;
-    status.obp[0][2] = (data >> 4) & 3;
-    status.obp[0][1] = (data >> 2) & 3;
-    status.obp[0][0] = (data >> 0) & 3;
+    obp[0][3] = (data >> 6) & 3;
+    obp[0][2] = (data >> 4) & 3;
+    obp[0][1] = (data >> 2) & 3;
+    obp[0][0] = (data >> 0) & 3;
     return;
   }
 
   if(addr == 0xff49) {  //OBP1
-    status.obp[1][3] = (data >> 6) & 3;
-    status.obp[1][2] = (data >> 4) & 3;
-    status.obp[1][1] = (data >> 2) & 3;
-    status.obp[1][0] = (data >> 0) & 3;
+    obp[1][3] = (data >> 6) & 3;
+    obp[1][2] = (data >> 4) & 3;
+    obp[1][1] = (data >> 2) & 3;
+    obp[1][0] = (data >> 0) & 3;
     return;
   }
 
@@ -164,6 +171,33 @@ void LCD::mmio_write(uint16 addr, uint8 data) {
     status.wx = data;
     return;
   }
+
+  if(addr == 0xff4f) {  //VBK
+    status.vram_bank = data & 1;
+    return;
+  }
+
+  if(addr == 0xff68) {  //BGPI
+    status.bgpi_increment = data & 0x80;
+    status.bgpi = data & 0x3f;
+    return;
+  }
+
+  if(addr == 0xff69) {  //BGPD
+    bgpd[status.bgpi] = data;
+    if(status.bgpi_increment) status.bgpi++;
+    return;
+  }
+
+  if(addr == 0xff6a) {  //OBPI
+    status.obpi_increment = data & 0x80;
+    status.obpi = data & 0x3f;
+  }
+
+  if(addr == 0xff6b) {  //OBPD
+    obpd[status.obpi] = data;
+    if(status.obpi_increment) status.obpi++;
+  }
 }
 
 #endif

bsnes/gameboy/lcd/mmio/mmio.hpp

@@ -1,2 +1,3 @@
+unsigned vram_addr(uint16 addr) const;
 uint8 mmio_read(uint16 addr);
 void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/lcd/serialization.cpp

@@ -1,6 +1,20 @@
 #ifdef LCD_CPP
 
 void LCD::serialize(serializer &s) {
+  Processor::serialize(s);
+
+  s.array(screen);
+  s.array(line);
+  s.array(origin);
+
+  s.array(vram);
+  s.array(oam);
+  s.array(bgp);
+  s.array(obp[0]);
+  s.array(obp[1]);
+  s.array(bgpd);
+  s.array(obpd);
+
   s.integer(status.lx);
   s.integer(status.wyc);
 
@@ -9,8 +23,8 @@ void LCD::serialize(serializer &s) {
   s.integer(status.window_display_enable);
   s.integer(status.bg_tiledata_select);
   s.integer(status.bg_tilemap_select);
-  s.integer(status.obj_size);
-  s.integer(status.obj_enable);
+  s.integer(status.ob_size);
+  s.integer(status.ob_enable);
   s.integer(status.bg_enable);
 
   s.integer(status.interrupt_lyc);
@@ -20,21 +34,20 @@ void LCD::serialize(serializer &s) {
 
   s.integer(status.scy);
   s.integer(status.scx);
+
   s.integer(status.ly);
   s.integer(status.lyc);
 
-  s.array(status.bgp);
-  s.array(status.obp[0]);
-  s.array(status.obp[1]);
-
   s.integer(status.wy);
   s.integer(status.wx);
 
-  s.array(screen);
-  s.array(vram);
-  s.array(oam);
-  s.array(line);
-  s.array(origin);
+  s.integer(status.vram_bank);
+
+  s.integer(status.bgpi_increment);
+  s.integer(status.bgpi);
+
+  s.integer(status.obpi_increment);
+  s.integer(status.obpi);
 }
 
 #endif

bsnes/gameboy/system/bootrom-cgb.cpp

@@ -0,0 +1,135 @@
+#ifdef SYSTEM_CPP
+
+//SHA256 = 4bf5021be357ce523a59ac5f4efff5d6371ae50112a6db0adf4a75916ad760a9
+const uint8_t System::BootROM::cgb[2048] = {
+  0x31,0xfe,0xff,0x3e,0x02,0xc3,0x7c,0x00,0xd3,0x00,0x98,0xa0,0x12,0xd3,0x00,0x80,
+  0x00,0x40,0x1e,0x53,0xd0,0x00,0x1f,0x42,0x1c,0x00,0x14,0x2a,0x4d,0x19,0x8c,0x7e,
+  0x00,0x7c,0x31,0x6e,0x4a,0x45,0x52,0x4a,0x00,0x00,0xff,0x53,0x1f,0x7c,0xff,0x03,
+  0x1f,0x00,0xff,0x1f,0xa7,0x00,0xef,0x1b,0x1f,0x00,0xef,0x1b,0x00,0x7c,0x00,0x00,
+  0xff,0x03,0xce,0xed,0x66,0x66,0xcc,0x0d,0x00,0x0b,0x03,0x73,0x00,0x83,0x00,0x0c,
+  0x00,0x0d,0x00,0x08,0x11,0x1f,0x88,0x89,0x00,0x0e,0xdc,0xcc,0x6e,0xe6,0xdd,0xdd,
+  0xd9,0x99,0xbb,0xbb,0x67,0x63,0x6e,0x0e,0xec,0xcc,0xdd,0xdc,0x99,0x9f,0xbb,0xb9,
+  0x33,0x3e,0x3c,0x42,0xb9,0xa5,0xb9,0xa5,0x42,0x3c,0x58,0x43,0xe0,0x70,0x3e,0xfc,
+  0xe0,0x47,0xcd,0x75,0x02,0xcd,0x00,0x02,0x26,0xd0,0xcd,0x03,0x02,0x21,0x00,0xfe,
+  0x0e,0xa0,0xaf,0x22,0x0d,0x20,0xfc,0x11,0x04,0x01,0x21,0x10,0x80,0x4c,0x1a,0xe2,
+  0x0c,0xcd,0xc6,0x03,0xcd,0xc7,0x03,0x13,0x7b,0xfe,0x34,0x20,0xf1,0x11,0x72,0x00,
+  0x06,0x08,0x1a,0x13,0x22,0x23,0x05,0x20,0xf9,0xcd,0xf0,0x03,0x3e,0x01,0xe0,0x4f,
+  0x3e,0x91,0xe0,0x40,0x21,0xb2,0x98,0x06,0x4e,0x0e,0x44,0xcd,0x91,0x02,0xaf,0xe0,
+  0x4f,0x0e,0x80,0x21,0x42,0x00,0x06,0x18,0xf2,0x0c,0xbe,0x20,0xfe,0x23,0x05,0x20,
+  0xf7,0x21,0x34,0x01,0x06,0x19,0x78,0x86,0x2c,0x05,0x20,0xfb,0x86,0x20,0xfe,0xcd,
+  0x1c,0x03,0x18,0x02,0x00,0x00,0xcd,0xd0,0x05,0xaf,0xe0,0x70,0x3e,0x11,0xe0,0x50,
+  0x21,0x00,0x80,0xaf,0x22,0xcb,0x6c,0x28,0xfb,0xc9,0x2a,0x12,0x13,0x0d,0x20,0xfa,
+  0xc9,0xe5,0x21,0x0f,0xff,0xcb,0x86,0xcb,0x46,0x28,0xfc,0xe1,0xc9,0x11,0x00,0xff,
+  0x21,0x03,0xd0,0x0e,0x0f,0x3e,0x30,0x12,0x3e,0x20,0x12,0x1a,0x2f,0xa1,0xcb,0x37,
+  0x47,0x3e,0x10,0x12,0x1a,0x2f,0xa1,0xb0,0x4f,0x7e,0xa9,0xe6,0xf0,0x47,0x2a,0xa9,
+  0xa1,0xb0,0x32,0x47,0x79,0x77,0x3e,0x30,0x12,0xc9,0x3e,0x80,0xe0,0x68,0xe0,0x6a,
+  0x0e,0x6b,0x2a,0xe2,0x05,0x20,0xfb,0x4a,0x09,0x43,0x0e,0x69,0x2a,0xe2,0x05,0x20,
+  0xfb,0xc9,0xc5,0xd5,0xe5,0x21,0x00,0xd8,0x06,0x01,0x16,0x3f,0x1e,0x40,0xcd,0x4a,
+  0x02,0xe1,0xd1,0xc1,0xc9,0x3e,0x80,0xe0,0x26,0xe0,0x11,0x3e,0xf3,0xe0,0x12,0xe0,
+  0x25,0x3e,0x77,0xe0,0x24,0x21,0x30,0xff,0xaf,0x0e,0x10,0x22,0x2f,0x0d,0x20,0xfb,
+  0xc9,0xcd,0x11,0x02,0xcd,0x62,0x02,0x79,0xfe,0x38,0x20,0x14,0xe5,0xaf,0xe0,0x4f,
+  0x21,0xa7,0x99,0x3e,0x38,0x22,0x3c,0xfe,0x3f,0x20,0xfa,0x3e,0x01,0xe0,0x4f,0xe1,
+  0xc5,0xe5,0x21,0x43,0x01,0xcb,0x7e,0xcc,0x89,0x05,0xe1,0xc1,0xcd,0x11,0x02,0x79,
+  0xd6,0x30,0xd2,0x06,0x03,0x79,0xfe,0x01,0xca,0x06,0x03,0x7d,0xfe,0xd1,0x28,0x21,
+  0xc5,0x06,0x03,0x0e,0x01,0x16,0x03,0x7e,0xe6,0xf8,0xb1,0x22,0x15,0x20,0xf8,0x0c,
+  0x79,0xfe,0x06,0x20,0xf0,0x11,0x11,0x00,0x19,0x05,0x20,0xe7,0x11,0xa1,0xff,0x19,
+  0xc1,0x04,0x78,0x1e,0x83,0xfe,0x62,0x28,0x06,0x1e,0xc1,0xfe,0x64,0x20,0x07,0x7b,
+  0xe0,0x13,0x3e,0x87,0xe0,0x14,0xfa,0x02,0xd0,0xfe,0x00,0x28,0x0a,0x3d,0xea,0x02,
+  0xd0,0x79,0xfe,0x01,0xca,0x91,0x02,0x0d,0xc2,0x91,0x02,0xc9,0x0e,0x26,0xcd,0x4a,
+  0x03,0xcd,0x11,0x02,0xcd,0x62,0x02,0x0d,0x20,0xf4,0xcd,0x11,0x02,0x3e,0x01,0xe0,
+  0x4f,0xcd,0x3e,0x03,0xcd,0x41,0x03,0xaf,0xe0,0x4f,0xcd,0x3e,0x03,0xc9,0x21,0x08,
+  0x00,0x11,0x51,0xff,0x0e,0x05,0xcd,0x0a,0x02,0xc9,0xc5,0xd5,0xe5,0x21,0x40,0xd8,
+  0x0e,0x20,0x7e,0xe6,0x1f,0xfe,0x1f,0x28,0x01,0x3c,0x57,0x2a,0x07,0x07,0x07,0xe6,
+  0x07,0x47,0x3a,0x07,0x07,0x07,0xe6,0x18,0xb0,0xfe,0x1f,0x28,0x01,0x3c,0x0f,0x0f,
+  0x0f,0x47,0xe6,0xe0,0xb2,0x22,0x78,0xe6,0x03,0x5f,0x7e,0x0f,0x0f,0xe6,0x1f,0xfe,
+  0x1f,0x28,0x01,0x3c,0x07,0x07,0xb3,0x22,0x0d,0x20,0xc7,0xe1,0xd1,0xc1,0xc9,0x0e,
+  0x00,0x1a,0xe6,0xf0,0xcb,0x49,0x28,0x02,0xcb,0x37,0x47,0x23,0x7e,0xb0,0x22,0x1a,
+  0xe6,0x0f,0xcb,0x49,0x20,0x02,0xcb,0x37,0x47,0x23,0x7e,0xb0,0x22,0x13,0xcb,0x41,
+  0x28,0x0d,0xd5,0x11,0xf8,0xff,0xcb,0x49,0x28,0x03,0x11,0x08,0x00,0x19,0xd1,0x0c,
+  0x79,0xfe,0x18,0x20,0xcc,0xc9,0x47,0xd5,0x16,0x04,0x58,0xcb,0x10,0x17,0xcb,0x13,
+  0x17,0x15,0x20,0xf6,0xd1,0x22,0x23,0x22,0x23,0xc9,0x3e,0x19,0xea,0x10,0x99,0x21,
+  0x2f,0x99,0x0e,0x0c,0x3d,0x28,0x08,0x32,0x0d,0x20,0xf9,0x2e,0x0f,0x18,0xf3,0xc9,
+  0x3e,0x01,0xe0,0x4f,0xcd,0x00,0x02,0x11,0x07,0x06,0x21,0x80,0x80,0x0e,0xc0,0x1a,
+  0x22,0x23,0x22,0x23,0x13,0x0d,0x20,0xf7,0x11,0x04,0x01,0xcd,0x8f,0x03,0x01,0xa8,
+  0xff,0x09,0xcd,0x8f,0x03,0x01,0xf8,0xff,0x09,0x11,0x72,0x00,0x0e,0x08,0x23,0x1a,
+  0x22,0x13,0x0d,0x20,0xf9,0x21,0xc2,0x98,0x06,0x08,0x3e,0x08,0x0e,0x10,0x22,0x0d,
+  0x20,0xfc,0x11,0x10,0x00,0x19,0x05,0x20,0xf3,0xaf,0xe0,0x4f,0x21,0xc2,0x98,0x3e,
+  0x08,0x22,0x3c,0xfe,0x18,0x20,0x02,0x2e,0xe2,0xfe,0x28,0x20,0x03,0x21,0x02,0x99,
+  0xfe,0x38,0x20,0xed,0x21,0xd8,0x08,0x11,0x40,0xd8,0x06,0x08,0x3e,0xff,0x12,0x13,
+  0x12,0x13,0x0e,0x02,0xcd,0x0a,0x02,0x3e,0x00,0x12,0x13,0x12,0x13,0x13,0x13,0x05,
+  0x20,0xea,0xcd,0x62,0x02,0x21,0x4b,0x01,0x7e,0xfe,0x33,0x20,0x0b,0x2e,0x44,0x1e,
+  0x30,0x2a,0xbb,0x20,0x49,0x1c,0x18,0x04,0x2e,0x4b,0x1e,0x01,0x2a,0xbb,0x20,0x3e,
+  0x2e,0x34,0x01,0x10,0x00,0x2a,0x80,0x47,0x0d,0x20,0xfa,0xea,0x00,0xd0,0x21,0xc7,
+  0x06,0x0e,0x00,0x2a,0xb8,0x28,0x08,0x0c,0x79,0xfe,0x4f,0x20,0xf6,0x18,0x1f,0x79,
+  0xd6,0x41,0x38,0x1c,0x21,0x16,0x07,0x16,0x00,0x5f,0x19,0xfa,0x37,0x01,0x57,0x7e,
+  0xba,0x28,0x0d,0x11,0x0e,0x00,0x19,0x79,0x83,0x4f,0xd6,0x5e,0x38,0xed,0x0e,0x00,
+  0x21,0x33,0x07,0x06,0x00,0x09,0x7e,0xe6,0x1f,0xea,0x08,0xd0,0x7e,0xe6,0xe0,0x07,
+  0x07,0x07,0xea,0x0b,0xd0,0xcd,0xe9,0x04,0xc9,0x11,0x91,0x07,0x21,0x00,0xd9,0xfa,
+  0x0b,0xd0,0x47,0x0e,0x1e,0xcb,0x40,0x20,0x02,0x13,0x13,0x1a,0x22,0x20,0x02,0x1b,
+  0x1b,0xcb,0x48,0x20,0x02,0x13,0x13,0x1a,0x22,0x13,0x13,0x20,0x02,0x1b,0x1b,0xcb,
+  0x50,0x28,0x05,0x1b,0x2b,0x1a,0x22,0x13,0x1a,0x22,0x13,0x0d,0x20,0xd7,0x21,0x00,
+  0xd9,0x11,0x00,0xda,0xcd,0x64,0x05,0xc9,0x21,0x12,0x00,0xfa,0x05,0xd0,0x07,0x07,
+  0x06,0x00,0x4f,0x09,0x11,0x40,0xd8,0x06,0x08,0xe5,0x0e,0x02,0xcd,0x0a,0x02,0x13,
+  0x13,0x13,0x13,0x13,0x13,0xe1,0x05,0x20,0xf0,0x11,0x42,0xd8,0x0e,0x02,0xcd,0x0a,
+  0x02,0x11,0x4a,0xd8,0x0e,0x02,0xcd,0x0a,0x02,0x2b,0x2b,0x11,0x44,0xd8,0x0e,0x02,
+  0xcd,0x0a,0x02,0xc9,0x0e,0x60,0x2a,0xe5,0xc5,0x21,0xe8,0x07,0x06,0x00,0x4f,0x09,
+  0x0e,0x08,0xcd,0x0a,0x02,0xc1,0xe1,0x0d,0x20,0xec,0xc9,0xfa,0x08,0xd0,0x11,0x18,
+  0x00,0x3c,0x3d,0x28,0x03,0x19,0x20,0xfa,0xc9,0xcd,0x1d,0x02,0x78,0xe6,0xff,0x28,
+  0x0f,0x21,0xe4,0x08,0x06,0x00,0x2a,0xb9,0x28,0x08,0x04,0x78,0xfe,0x0c,0x20,0xf6,
+  0x18,0x2d,0x78,0xea,0x05,0xd0,0x3e,0x1e,0xea,0x02,0xd0,0x11,0x0b,0x00,0x19,0x56,
+  0x7a,0xe6,0x1f,0x5f,0x21,0x08,0xd0,0x3a,0x22,0x7b,0x77,0x7a,0xe6,0xe0,0x07,0x07,
+  0x07,0x5f,0x21,0x0b,0xd0,0x3a,0x22,0x7b,0x77,0xcd,0xe9,0x04,0xcd,0x28,0x05,0xc9,
+  0xcd,0x11,0x02,0xfa,0x43,0x01,0xcb,0x7f,0x28,0x04,0xe0,0x4c,0x18,0x28,0x3e,0x04,
+  0xe0,0x4c,0x3e,0x01,0xe0,0x6c,0x21,0x00,0xda,0xcd,0x7b,0x05,0x06,0x10,0x16,0x00,
+  0x1e,0x08,0xcd,0x4a,0x02,0x21,0x7a,0x00,0xfa,0x00,0xd0,0x47,0x0e,0x02,0x2a,0xb8,
+  0xcc,0xda,0x03,0x0d,0x20,0xf8,0xc9,0x01,0x0f,0x3f,0x7e,0xff,0xff,0xc0,0x00,0xc0,
+  0xf0,0xf1,0x03,0x7c,0xfc,0xfe,0xfe,0x03,0x07,0x07,0x0f,0xe0,0xe0,0xf0,0xf0,0x1e,
+  0x3e,0x7e,0xfe,0x0f,0x0f,0x1f,0x1f,0xff,0xff,0x00,0x00,0x01,0x01,0x01,0x03,0xff,
+  0xff,0xe1,0xe0,0xc0,0xf0,0xf9,0xfb,0x1f,0x7f,0xf8,0xe0,0xf3,0xfd,0x3e,0x1e,0xe0,
+  0xf0,0xf9,0x7f,0x3e,0x7c,0xf8,0xe0,0xf8,0xf0,0xf0,0xf8,0x00,0x00,0x7f,0x7f,0x07,
+  0x0f,0x9f,0xbf,0x9e,0x1f,0xff,0xff,0x0f,0x1e,0x3e,0x3c,0xf1,0xfb,0x7f,0x7f,0xfe,
+  0xde,0xdf,0x9f,0x1f,0x3f,0x3e,0x3c,0xf8,0xf8,0x00,0x00,0x03,0x03,0x07,0x07,0xff,
+  0xff,0xc1,0xc0,0xf3,0xe7,0xf7,0xf3,0xc0,0xc0,0xc0,0xc0,0x1f,0x1f,0x1e,0x3e,0x3f,
+  0x1f,0x3e,0x3e,0x80,0x00,0x00,0x00,0x7c,0x1f,0x07,0x00,0x0f,0xff,0xfe,0x00,0x7c,
+  0xf8,0xf0,0x00,0x1f,0x0f,0x0f,0x00,0x7c,0xf8,0xf8,0x00,0x3f,0x3e,0x1c,0x00,0x0f,
+  0x0f,0x0f,0x00,0x7c,0xff,0xff,0x00,0x00,0xf8,0xf8,0x00,0x07,0x0f,0x0f,0x00,0x81,
+  0xff,0xff,0x00,0xf3,0xe1,0x80,0x00,0xe0,0xff,0x7f,0x00,0xfc,0xf0,0xc0,0x00,0x3e,
+  0x7c,0x7c,0x00,0x00,0x00,0x00,0x00,0x00,0x88,0x16,0x36,0xd1,0xdb,0xf2,0x3c,0x8c,
+  0x92,0x3d,0x5c,0x58,0xc9,0x3e,0x70,0x1d,0x59,0x69,0x19,0x35,0xa8,0x14,0xaa,0x75,
+  0x95,0x99,0x34,0x6f,0x15,0xff,0x97,0x4b,0x90,0x17,0x10,0x39,0xf7,0xf6,0xa2,0x49,
+  0x4e,0x43,0x68,0xe0,0x8b,0xf0,0xce,0x0c,0x29,0xe8,0xb7,0x86,0x9a,0x52,0x01,0x9d,
+  0x71,0x9c,0xbd,0x5d,0x6d,0x67,0x3f,0x6b,0xb3,0x46,0x28,0xa5,0xc6,0xd3,0x27,0x61,
+  0x18,0x66,0x6a,0xbf,0x0d,0xf4,0x42,0x45,0x46,0x41,0x41,0x52,0x42,0x45,0x4b,0x45,
+  0x4b,0x20,0x52,0x2d,0x55,0x52,0x41,0x52,0x20,0x49,0x4e,0x41,0x49,0x4c,0x49,0x43,
+  0x45,0x20,0x52,0x7c,0x08,0x12,0xa3,0xa2,0x07,0x87,0x4b,0x20,0x12,0x65,0xa8,0x16,
+  0xa9,0x86,0xb1,0x68,0xa0,0x87,0x66,0x12,0xa1,0x30,0x3c,0x12,0x85,0x12,0x64,0x1b,
+  0x07,0x06,0x6f,0x6e,0x6e,0xae,0xaf,0x6f,0xb2,0xaf,0xb2,0xa8,0xab,0x6f,0xaf,0x86,
+  0xae,0xa2,0xa2,0x12,0xaf,0x13,0x12,0xa1,0x6e,0xaf,0xaf,0xad,0x06,0x4c,0x6e,0xaf,
+  0xaf,0x12,0x7c,0xac,0xa8,0x6a,0x6e,0x13,0xa0,0x2d,0xa8,0x2b,0xac,0x64,0xac,0x6d,
+  0x87,0xbc,0x60,0xb4,0x13,0x72,0x7c,0xb5,0xae,0xae,0x7c,0x7c,0x65,0xa2,0x6c,0x64,
+  0x85,0x80,0xb0,0x40,0x88,0x20,0x68,0xde,0x00,0x70,0xde,0x20,0x78,0x20,0x20,0x38,
+  0x20,0xb0,0x90,0x20,0xb0,0xa0,0xe0,0xb0,0xc0,0x98,0xb6,0x48,0x80,0xe0,0x50,0x1e,
+  0x1e,0x58,0x20,0xb8,0xe0,0x88,0xb0,0x10,0x20,0x00,0x10,0x20,0xe0,0x18,0xe0,0x18,
+  0x00,0x18,0xe0,0x20,0xa8,0xe0,0x20,0x18,0xe0,0x00,0x20,0x18,0xd8,0xc8,0x18,0xe0,
+  0x00,0xe0,0x40,0x28,0x28,0x28,0x18,0xe0,0x60,0x20,0x18,0xe0,0x00,0x00,0x08,0xe0,
+  0x18,0x30,0xd0,0xd0,0xd0,0x20,0xe0,0xe8,0xff,0x7f,0xbf,0x32,0xd0,0x00,0x00,0x00,
+  0x9f,0x63,0x79,0x42,0xb0,0x15,0xcb,0x04,0xff,0x7f,0x31,0x6e,0x4a,0x45,0x00,0x00,
+  0xff,0x7f,0xef,0x1b,0x00,0x02,0x00,0x00,0xff,0x7f,0x1f,0x42,0xf2,0x1c,0x00,0x00,
+  0xff,0x7f,0x94,0x52,0x4a,0x29,0x00,0x00,0xff,0x7f,0xff,0x03,0x2f,0x01,0x00,0x00,
+  0xff,0x7f,0xef,0x03,0xd6,0x01,0x00,0x00,0xff,0x7f,0xb5,0x42,0xc8,0x3d,0x00,0x00,
+  0x74,0x7e,0xff,0x03,0x80,0x01,0x00,0x00,0xff,0x67,0xac,0x77,0x13,0x1a,0x6b,0x2d,
+  0xd6,0x7e,0xff,0x4b,0x75,0x21,0x00,0x00,0xff,0x53,0x5f,0x4a,0x52,0x7e,0x00,0x00,
+  0xff,0x4f,0xd2,0x7e,0x4c,0x3a,0xe0,0x1c,0xed,0x03,0xff,0x7f,0x5f,0x25,0x00,0x00,
+  0x6a,0x03,0x1f,0x02,0xff,0x03,0xff,0x7f,0xff,0x7f,0xdf,0x01,0x12,0x01,0x00,0x00,
+  0x1f,0x23,0x5f,0x03,0xf2,0x00,0x09,0x00,0xff,0x7f,0xea,0x03,0x1f,0x01,0x00,0x00,
+  0x9f,0x29,0x1a,0x00,0x0c,0x00,0x00,0x00,0xff,0x7f,0x7f,0x02,0x1f,0x00,0x00,0x00,
+  0xff,0x7f,0xe0,0x03,0x06,0x02,0x20,0x01,0xff,0x7f,0xeb,0x7e,0x1f,0x00,0x00,0x7c,
+  0xff,0x7f,0xff,0x3f,0x00,0x7e,0x1f,0x00,0xff,0x7f,0xff,0x03,0x1f,0x00,0x00,0x00,
+  0xff,0x03,0x1f,0x00,0x0c,0x00,0x00,0x00,0xff,0x7f,0x3f,0x03,0x93,0x01,0x00,0x00,
+  0x00,0x00,0x00,0x42,0x7f,0x03,0xff,0x7f,0xff,0x7f,0x8c,0x7e,0x00,0x7c,0x00,0x00,
+  0xff,0x7f,0xef,0x1b,0x80,0x61,0x00,0x00,0xff,0x7f,0x00,0x7c,0xe0,0x03,0x1f,0x7c,
+  0x1f,0x00,0xff,0x03,0x40,0x41,0x42,0x20,0x21,0x22,0x80,0x81,0x82,0x10,0x11,0x12,
+  0x12,0xb0,0x79,0xb8,0xad,0x16,0x17,0x07,0xba,0x05,0x7c,0x13,0x00,0x00,0x00,0x00,
+};
+
+#endif

bsnes/gameboy/system/bootrom-dmg.cpp

@@ -1,6 +1,6 @@
 #ifdef SYSTEM_CPP
 
-//MD5SUM = 32fbbd84168d3482956eb3c5051637f5
+//SHA256 = cf053eccb4ccafff9e67339d4e78e98dce7d1ed59be819d2a1ba2232c6fce1c7
 const uint8_t System::BootROM::dmg[256] = {
   0x31,0xfe,0xff,0xaf,0x21,0xff,0x9f,0x32,0xcb,0x7c,0x20,0xfb,0x21,0x26,0xff,0x0e,
   0x11,0x3e,0x80,0x32,0xe2,0x0c,0x3e,0xf3,0xe2,0x32,0x3e,0x77,0x77,0x3e,0xfc,0xe0,

bsnes/gameboy/system/bootrom-sgb.cpp

@@ -1,6 +1,6 @@
 #ifdef SYSTEM_CPP
 
-//MD5SUM = d574d4f9c12f305074798f54c091a8b4
+//SHA256 = 0e4ddff32fc9d1eeaae812a157dd246459b00c9e14f2f61751f661f32361e360
 const uint8_t System::BootROM::sgb[256] = {
   0x31,0xfe,0xff,0x3e,0x30,0xe0,0x00,0xaf,0x21,0xff,0x9f,0x32,0xcb,0x7c,0x20,0xfb,
   0x21,0x26,0xff,0x0e,0x11,0x3e,0x80,0x32,0xe2,0x0c,0x3e,0xf3,0xe2,0x32,0x3e,0x77,

bsnes/gameboy/system/serialization.cpp

@@ -29,6 +29,7 @@ bool System::unserialize(serializer &s) {
   if(version != Info::SerializerVersion) return false;
 //if(crc32 != 0) return false;
 
+  power();
   serialize_all(s);
   return true;
 }

bsnes/gameboy/system/system.cpp

@@ -5,6 +5,7 @@ namespace GameBoy {
 
 #include "bootrom-dmg.cpp"
 #include "bootrom-sgb.cpp"
+#include "bootrom-cgb.cpp"
 #include "serialization.cpp"
 System system;
 
@@ -37,7 +38,8 @@ void System::init() {
   assert(interface != 0);
 }
 
-void System::load() {
+void System::load(Revision revision) {
+  this->revision = revision;
   serialize_init();
 }
 

bsnes/gameboy/system/system.hpp

@@ -4,10 +4,21 @@ enum class Input : unsigned {
   Up, Down, Left, Right, B, A, Select, Start,
 };
 
-struct System {
+struct System : property<System> {
+  enum class Revision : unsigned {
+    GameBoy,
+    SuperGameBoy,
+    GameBoyColor,
+  };
+  readonly<Revision> revision;
+  inline bool dmg() const { return revision == Revision::GameBoy; }
+  inline bool sgb() const { return revision == Revision::SuperGameBoy; }
+  inline bool cgb() const { return revision == Revision::GameBoyColor; }
+
   struct BootROM {
-    static const uint8 dmg[256];
-    static const uint8 sgb[256];
+    static const uint8 dmg[ 256];
+    static const uint8 sgb[ 256];
+    static const uint8 cgb[2048];
   } bootROM;
 
   void run();
@@ -15,7 +26,7 @@ struct System {
   void runthreadtosave();
 
   void init();
-  void load();
+  void load(Revision);
   void power();
 
   unsigned clocks_executed;

bsnes/gameboy/video/video.cpp

@@ -0,0 +1,82 @@
+#include <gameboy/gameboy.hpp>
+
+#define VIDEO_CPP
+namespace GameBoy {
+
+Video video;
+
+unsigned Video::palette_dmg(unsigned color) const {
+  unsigned R = monochrome[color][0] * 1023.0;
+  unsigned G = monochrome[color][1] * 1023.0;
+  unsigned B = monochrome[color][2] * 1023.0;
+
+  return (R << 20) + (G << 10) + (B << 0);
+}
+
+unsigned Video::palette_sgb(unsigned color) const {
+  unsigned R = (3 - color) * 341;
+  unsigned G = (3 - color) * 341;
+  unsigned B = (3 - color) * 341;
+
+  return (R << 20) + (G << 10) + (B << 0);
+}
+
+unsigned Video::palette_cgb(unsigned color) const {
+  unsigned r = (color >>  0) & 31;
+  unsigned g = (color >>  5) & 31;
+  unsigned b = (color >> 10) & 31;
+
+  unsigned R = (r * 26 + g *  4 + b *  2);
+  unsigned G = (         g * 24 + b *  8);
+  unsigned B = (r *  6 + g *  4 + b * 22);
+
+  R = min(960, R);
+  G = min(960, G);
+  B = min(960, B);
+
+  return (R << 20) + (G << 10) + (B << 0);
+}
+
+void Video::generate(Format format) {
+  if(system.dmg()) for(unsigned n = 0; n < 4; n++) palette[n] = palette_dmg(n);
+  if(system.sgb()) for(unsigned n = 0; n < 4; n++) palette[n] = palette_sgb(n);
+  if(system.cgb()) for(unsigned n = 0; n < (1 << 15); n++) palette[n] = palette_cgb(n);
+
+  if(format == Format::RGB24) {
+    for(unsigned n = 0; n < (1 << 15); n++) {
+      unsigned color = palette[n];
+      palette[n] = ((color >> 6) & 0xff0000) + ((color >> 4) & 0x00ff00) + ((color >> 2) & 0x0000ff);
+    }
+  }
+
+  if(format == Format::RGB16) {
+    for(unsigned n = 0; n < (1 << 15); n++) {
+      unsigned color = palette[n];
+      palette[n] = ((color >> 14) & 0xf800) + ((color >> 9) & 0x07e0) + ((color >> 5) & 0x001f);
+    }
+  }
+
+  if(format == Format::RGB15) {
+    for(unsigned n = 0; n < (1 << 15); n++) {
+      unsigned color = palette[n];
+      palette[n] = ((color >> 15) & 0x7c00) + ((color >> 10) & 0x03e0) + ((color >> 5) & 0x001f);
+    }
+  }
+}
+
+Video::Video() {
+  palette = new unsigned[1 << 15];
+}
+
+Video::~Video() {
+  delete[] palette;
+}
+
+const double Video::monochrome[4][3] = {
+  { 0.605, 0.734, 0.059 },
+  { 0.543, 0.672, 0.059 },
+  { 0.188, 0.383, 0.188 },
+  { 0.059, 0.219, 0.059 },
+};
+
+}

bsnes/gameboy/video/video.hpp

@@ -0,0 +1,17 @@
+struct Video {
+  enum class Format : unsigned { RGB30, RGB24, RGB16, RGB15 };
+  unsigned *palette;
+
+  unsigned palette_dmg(unsigned color) const;
+  unsigned palette_sgb(unsigned color) const;
+  unsigned palette_cgb(unsigned color) const;
+
+  void generate(Format format);
+  Video();
+  ~Video();
+
+private:
+  static const double monochrome[4][3];
+};
+
+extern Video video;

bsnes/nall/Makefile

@@ -19,6 +19,9 @@ ifeq ($(platform),)
   ifeq ($(uname),)
     platform := win
     delete = del $(subst /,\,$1)
+  else ifneq ($(findstring CYGWIN,$(uname)),)
+    platform := win
+    delete = del $(subst /,\,$1)
   else ifneq ($(findstring Darwin,$(uname)),)
     platform := osx
     delete = rm -f $1
@@ -38,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/array.hpp

@@ -118,16 +118,21 @@ namespace nall {
       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];
+    //access
+    inline T& operator[](unsigned position) {
+      if(position >= buffersize) resize(position + 1);
+      if(position >= buffersize) throw "array[] out of bounds";
+      return pool[position];
     }
 
-    inline const T& operator[](unsigned index) const {
-      if(index >= buffersize) throw "array[] out of bounds";
-      return pool[index];
+    inline const T& operator[](unsigned position) const {
+      if(position >= buffersize) throw "array[] out of bounds";
+      return pool[position];
+    }
+
+    inline const T& operator()(unsigned position, const T& data) {
+      if(position >= buffersize) return data;
+      return pool[position];
     }
 
     //iteration

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/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/hid.hpp

@@ -0,0 +1,55 @@
+#ifndef NALL_HID_HPP
+#define NALL_HID_HPP
+
+#include <nall/xorg/xorg.hpp>
+#include <nall/input.hpp>
+
+namespace nall {
+namespace HID {
+
+struct Keyboard {
+  XlibDisplay *display;
+
+  inline void poll() {
+    XQueryKeymap(display, state);
+  }
+
+  inline bool operator[](unsigned id) {
+    return state[scancode[id] >> 3] & (1 << (scancode[id] & 7));
+  }
+
+  inline Keyboard() {
+    display = XOpenDisplay(0);
+    memset(&scancode, 0, sizeof scancode);
+
+    #define map(key, sym) scancode[key] = XKeysymToKeycode(display, sym)
+
+    using nall::Keyboard;
+    map(Keyboard::Insert, XK_Insert);
+    map(Keyboard::Delete, XK_Delete);
+    map(Keyboard::Home, XK_Home);
+    map(Keyboard::End, XK_End);
+    map(Keyboard::PageUp, XK_Prior);
+    map(Keyboard::PageDown, XK_Next);
+
+    map(Keyboard::Up, XK_Up);
+    map(Keyboard::Down, XK_Down);
+    map(Keyboard::Left, XK_Left);
+    map(Keyboard::Right, XK_Right);
+
+    #undef map
+  }
+
+  inline ~Keyboard() {
+    XCloseDisplay(display);
+  }
+
+private:
+  char state[32];
+  uint8_t scancode[256];
+};
+
+}
+}
+
+#endif

bsnes/nall/image.hpp

@@ -0,0 +1,443 @@
+#ifndef NALL_IMAGE_HPP
+#define NALL_IMAGE_HPP
+
+#include <nall/bmp.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 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 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() {
+  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) {
+  scaleX(outputWidth, op);
+  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;
+
+  #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] = { read(sp), read(sp), read(sp), read(sp) };
+
+    for(unsigned x = 0; x < width; x++) {
+      if(sp >= data + pitch * height) break;
+      s[0] = s[1];
+      s[1] = s[2];
+      s[2] = s[3];
+      s[3] = read(sp);
+
+      while(fraction <= 1.0) {
+        if(dp >= outputData + outputPitch * height) break;
+        write(dp, interpolate(fraction, (const uint64_t*)&s, op));
+        dp += stride;
+        fraction += step;
+      }
+
+      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;
+
+  #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] = { read(sp), read(sp), read(sp), read(sp) };
+
+    for(unsigned y = 0; y < height; y++) {
+      if(sp >= data + pitch * height) break;
+      s[0] = s[1];
+      s[1] = s[2];
+      s[2] = s[3];
+      s[3] = read(sp);
+
+      while(fraction <= 1.0) {
+        if(dp >= outputData + pitch * outputHeight) break;
+        write(dp, interpolate(fraction, (const uint64_t*)&s, op));
+        dp += pitch;
+        fraction += step;
+      }
+
+      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 string &filename) {
+  png source;
+  if(source.decode(filename) == 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;
+}
+
+}
+
+#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 ? c : d);
+  }
+
+  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 c * (1.0 - mu) + d * mu;
+  }
+
+  static inline double Linear(double mu, double a, double b, double c, double d) {
+    return c * (1.0 - mu) + d * 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 c * (1.0 - mu) + d * 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/intrinsics.hpp

@@ -20,6 +20,7 @@ struct Intrinsics {
   #define COMPILER_VISUALC
   Intrinsics::Compiler Intrinsics::compiler() { return Intrinsics::Compiler::VisualC; }
 #else
+  #warning "unable to detect compiler"
   #define COMPILER_UNKNOWN
   Intrinsics::Compiler Intrinsics::compiler() { return Intrinsics::Compiler::Unknown; }
 #endif
@@ -37,8 +38,9 @@ struct Intrinsics {
   #define PLATFORM_WIN
   Intrinsics::Platform Intrinsics::platform() { return Intrinsics::Platform::Windows; }
 #else
+  #warning "unable to detect platform"
   #define PLATFORM_UNKNOWN
-  
+  Intrinsics::Platform Intrinsics::platform() { return Intrinsics::Platform::Unknown; }
 #endif
 
 /* Endian detection */
@@ -52,9 +54,10 @@ struct Intrinsics {
   #define ARCH_MSB
   Intrinsics::Endian Intrinsics::endian() { return Intrinsics::Endian::MSB; }
 #else
+  #warning "unable to detect endian"
   #define ENDIAN_UNKNOWN
   #define ARCH_UNKNOWN
-  Intrinsics::Endian Intrinsics::endia() { return Intrinsics::Endian::Unknown; }
+  Intrinsics::Endian Intrinsics::endian() { return Intrinsics::Endian::Unknown; }
 #endif
 
 #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/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/reference_array.hpp

@@ -7,9 +7,11 @@
 
 namespace nall {
   template<typename T> struct reference_array {
+    struct exception_out_of_bounds{};
+
   protected:
-    typedef typename std::remove_reference<T>::type *Tptr;
-    Tptr *pool;
+    typedef typename std::remove_reference<T>::type type_t;
+    type_t **pool;
     unsigned poolsize, buffersize;
 
   public:
@@ -26,7 +28,7 @@ namespace nall {
     void reserve(unsigned newsize) {
       if(newsize == poolsize) return;
 
-      pool = (Tptr*)realloc(pool, newsize * sizeof(T));
+      pool = (type_t**)realloc(pool, sizeof(type_t*) * newsize);
       poolsize = newsize;
       buffersize = min(buffersize, newsize);
     }
@@ -36,7 +38,14 @@ namespace nall {
       buffersize = newsize;
     }
 
-    bool append(const T data) {
+    template<typename... Args>
+    bool append(type_t& data, Args&&... args) {
+      bool result = append(data);
+      append(std::forward<Args>(args)...);
+      return result;
+    }
+
+    bool append(type_t& data) {
       for(unsigned index = 0; index < buffersize; index++) {
         if(pool[index] == &data) return false;
       }
@@ -47,7 +56,7 @@ namespace nall {
       return true;
     }
 
-    bool remove(const T data) {
+    bool remove(type_t& data) {
       for(unsigned index = 0; index < buffersize; index++) {
         if(pool[index] == &data) {
           for(unsigned i = index; i < buffersize - 1; i++) pool[i] = pool[i + 1];
@@ -70,8 +79,8 @@ namespace nall {
       if(pool) free(pool);
       buffersize = source.buffersize;
       poolsize = source.poolsize;
-      pool = (Tptr*)malloc(sizeof(T) * poolsize);
-      memcpy(pool, source.pool, sizeof(T) * buffersize);
+      pool = (type_t**)malloc(sizeof(type_t*) * poolsize);
+      memcpy(pool, source.pool, sizeof(type_t*) * buffersize);
       return *this;
     }
 
@@ -85,20 +94,20 @@ namespace nall {
       return *this;
     }
 
-    inline T operator[](unsigned index) {
-      if(index >= buffersize) throw "reference_array[] out of bounds";
+    inline type_t& operator[](unsigned index) {
+      if(index >= buffersize) throw exception_out_of_bounds();
       return *pool[index];
     }
 
-    inline const T operator[](unsigned index) const {
-      if(index >= buffersize) throw "reference_array[] out of bounds";
+    inline type_t& operator[](unsigned index) const {
+      if(index >= buffersize) throw exception_out_of_bounds();
       return *pool[index];
     }
 
     //iteration
     struct iterator {
       bool operator!=(const iterator &source) const { return index != source.index; }
-      T& operator*() { return array.operator[](index); }
+      type_t& operator*() { return array.operator[](index); }
       iterator& operator++() { index++; return *this; }
       iterator(const reference_array &array, unsigned index) : array(array), index(index) {}
     private:

bsnes/nall/snes/cartridge.hpp

@@ -105,345 +105,438 @@ 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.bin' 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");
-    }
+    markup.append("  <necdsp model='uPD7725' frequency='8000000' firmware='dsp1b.bin' sha256='4d42db0f36faef263d6b93f508e8c1c4ae8fc2605fd35e3390ecc02905cd420c'>\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.bin' sha256='5efbdf96ed0652790855225964f3e90e6a4d466cfa64df25b110933c6cf94ea1'>\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.bin' sha256='2e635f72e4d4681148bc35429421c9b946e4f407590e74e31b93b8987b63ba90'>\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.bin' sha256='63ede17322541c191ed1fdf683872554a0a57306496afc43c59de7c01a6e764a'>\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='st0010.bin' sha256='55c697e864562445621cdf8a7bf6e84ae91361e393d382a3704e9aa55559041e'>\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='st0011.bin' sha256='651b82a1e26c4fa8dd549e91e7f923012ed2ca54c1d9fd858655ab30679c2f0e'>\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(
+    "  <setarisc firmware='ST-0018'>\n"
+    "    <map address='00-3f:3800-38ff'/>\n"
+    "    <map address='80-bf:3800-38ff'/>\n"
+    "  </setarisc>\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/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>
@@ -31,6 +32,8 @@
 #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/strpos.hpp>
@@ -39,8 +42,10 @@
 #include <nall/string/split.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>
+#include <nall/string/xml-legacy.hpp>
 #undef NALL_STRING_INTERNAL_HPP
 
 #endif

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,12 @@ 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;
+    template<unsigned Limit = 0> inline lstring qsplit(const char*) const;
+    template<unsigned Limit = 0> inline lstring iqsplit(const char*) const;
 
     inline bool equals(const char*) const;
     inline bool iequals(const char*) const;
@@ -102,9 +109,7 @@ namespace nall {
   #endif
   };
 
-  struct lstring : public linear_vector<string> {
-    template<typename T> inline lstring& operator<<(T value);
-
+  struct lstring : vector<string> {
     inline optional<unsigned> find(const char*) const;
     template<unsigned Limit = 0> inline lstring& split(const char*, const char*);
     template<unsigned Limit = 0> inline lstring& isplit(const char*, const char*);
@@ -125,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);
@@ -173,17 +176,24 @@ namespace nall {
   inline string substr(const char *src, unsigned start = 0, unsigned length = ~0u);
   inline string sha256(const uint8_t *data, unsigned size);
 
+  inline char* integer(char *result, intmax_t value);
+  inline char* decimal(char *result, uintmax_t value);
+
   template<unsigned length = 0, char padding = ' '> inline string integer(intmax_t value);
   template<unsigned length = 0, char padding = ' '> inline string linteger(intmax_t value);
   template<unsigned length = 0, char padding = ' '> inline string decimal(uintmax_t value);
   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/cast.hpp

@@ -2,31 +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<signed int>    (signed int v)     { static char temp[256]; snprintf(temp, 255, "%+d", v); return temp; }
-template<> inline const char* to_string<unsigned int>  (unsigned int v)   { static char temp[256]; snprintf(temp, 255, "%u", v); return temp; }
-template<> inline const char* to_string<intmax_t>      (intmax_t v)       { static char temp[256]; snprintf(temp, 255, "%+lld", (long long)v); return temp; }
-template<> inline const char* to_string<uintmax_t>     (uintmax_t v)      { static char temp[256]; snprintf(temp, 255, "%llu", (unsigned long long)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<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; }
+//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<typename T> lstring& lstring::operator<<(T value) {
-  operator[](size()).assign(to_string<T>(value));
-  return *this;
-}
+// base types
+
+template<> struct stringify<bool> {
+  bool value;
+  operator const char*() const { return value ? "true" : "false"; }
+  stringify(bool value) : value(value) {}
+};
+
+template<> struct stringify<char> {
+  char data[256];
+  operator const char*() const { return data; }
+  stringify(char value) { integer(data, value); }
+};
+
+// 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)...);
@@ -151,9 +155,7 @@ inline lstring::lstring() {
 }
 
 inline lstring::lstring(std::initializer_list<string> list) {
-  for(const string *s = list.begin(); s != list.end(); ++s) {
-    operator<<(*s);
-  }
+  for(auto &data : list) append(data);
 }
 
 }

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/math.hpp

@@ -86,8 +86,8 @@ static int eval(const char *&s, int depth = 0) {
 
     if(depth >= 13) break;
     if(x == '*') { value *= eval(++s, 13); continue; }
-    if(x == '/') { value /= eval(++s, 13); continue; }
-    if(x == '%') { value %= eval(++s, 13); continue; }
+    if(x == '/') { int result = eval(++s, 13); if(result == 0) throw "division_by_zero"; value /= result; continue; }
+    if(x == '%') { int 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; }

bsnes/nall/string/split.hpp

@@ -7,14 +7,13 @@ template<unsigned Limit, bool Insensitive, bool Quoted> lstring& lstring::usplit
   if(!key || !*key) return *this;
 
   const char *p = base;
-  unsigned counter = 0;
 
   while(*p) {
-    if(Limit) if(counter >= Limit) break;
+    if(Limit) if(size() >= Limit) break;
     if(quoteskip<Quoted>(p)) continue;
     for(unsigned n = 0;; n++) {
       if(key[n] == 0) {
-        strlcpy(operator[](counter++), base, (unsigned)(p - base + 1));
+        append(substr(base, 0, p - base));
         p += n;
         base = p;
         break;
@@ -23,7 +22,7 @@ template<unsigned Limit, bool Insensitive, bool Quoted> lstring& lstring::usplit
     }
   }
 
-  operator[](counter) = base;
+  append(base);
   return *this;
 }
 

bsnes/nall/string/utility.hpp

@@ -68,11 +68,47 @@ string sha256(const uint8_t *data, unsigned size) {
   return result;
 }
 
-/* arithmetic <> string */
+/* cast.hpp arithmetic -> string */
+
+char* integer(char *result, intmax_t value) {
+  bool negative = value < 0;
+  if(negative) value = -value;
+
+  char buffer[64];
+  unsigned size = 0;
+
+  do {
+    unsigned n = value % 10;
+    buffer[size++] = '0' + n;
+    value /= 10;
+  } while(value);
+  buffer[size++] = negative ? '-' : '+';
+
+  for(signed x = size - 1, y = 0; x >= 0 && y < size; x--, y++) result[x] = buffer[y];
+  result[size] = 0;
+  return result;
+}
+
+char* decimal(char *result, uintmax_t value) {
+  char buffer[64];
+  unsigned size = 0;
+
+  do {
+    unsigned n = value % 10;
+    buffer[size++] = '0' + n;
+    value /= 10;
+  } while(value);
+
+  for(signed x = size - 1, y = 0; x >= 0 && y < size; x--, y++) result[x] = buffer[y];
+  result[size] = 0;
+  return result;
+}
+
+/* general-purpose arithmetic -> string */
 
 template<unsigned length_, char padding> string integer(intmax_t value) {
   bool negative = value < 0;
-  if(negative) value = abs(value);
+  if(negative) value = -value;
 
   char buffer[64];
   unsigned size = 0;
@@ -99,7 +135,7 @@ template<unsigned length_, char padding> string integer(intmax_t value) {
 
 template<unsigned length_, char padding> string linteger(intmax_t value) {
   bool negative = value < 0;
-  if(negative) value = abs(value);
+  if(negative) value = -value;
 
   char buffer[64];
   unsigned size = 0;
@@ -217,9 +253,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++) {
@@ -238,7 +279,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,12 @@
 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; }
+template<unsigned limit> lstring string::qsplit(const char *key) const { lstring result; result.qsplit<limit>(key, data); return result; }
+template<unsigned limit> lstring string::iqsplit(const char *key) const { lstring result; result.iqsplit<limit>(key, data); return result; }
 
 bool string::equals(const char *str) const { return !strcmp(data, str); }
 bool string::iequals(const char *str) const { return !istrcmp(data, str); }

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/vector.hpp

@@ -11,6 +11,121 @@
 #include <nall/utility.hpp>
 
 namespace nall {
+  template<typename T> struct vector {
+    struct exception_out_of_bounds{};
+
+  protected:
+    T *pool;
+    unsigned poolsize;
+    unsigned objectsize;
+
+  public:
+    unsigned size() const { return objectsize; }
+    unsigned capacity() const { return poolsize; }
+
+    void reset() {
+      if(pool) {
+        for(unsigned n = 0; n < objectsize; n++) pool[n].~T();
+        free(pool);
+      }
+      pool = nullptr;
+      poolsize = 0;
+      objectsize = 0;
+    }
+
+    void reserve(unsigned size) {
+      size = bit::round(size);  //amortize growth
+      T *copy = (T*)calloc(size, sizeof(T));
+      for(unsigned n = 0; n < min(size, objectsize); n++) new(copy + n) T(pool[n]);
+      for(unsigned n = 0; n < objectsize; n++) pool[n].~T();
+      free(pool);
+      pool = copy;
+      poolsize = size;
+      objectsize = min(size, objectsize);
+    }
+
+    template<typename... Args>
+    void append(const T& data, Args&&... args) {
+      append(data);
+      append(std::forward<Args>(args)...);
+    }
+
+    void append(const T& data) {
+      if(objectsize + 1 > poolsize) reserve(objectsize + 1);
+      new(pool + objectsize++) T(data);
+    }
+
+    void prepend(const T& data) {
+      append(data);
+      for(unsigned n = objectsize - 1; n; n--) swap(pool[n], pool[n - 1]);
+    }
+
+    void remove(unsigned index, unsigned count = 1) {
+      for(unsigned n = index; count + n < objectsize; n++) {
+        pool[n] = pool[count + n];
+      }
+      objectsize = (count + index >= objectsize) ? index : objectsize - count;
+    }
+
+    //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 const T& operator()(unsigned position, const T& data) const {
+      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]; }
+
+    //copy
+    inline vector& operator=(const vector &source) {
+      reset();
+      reserve(source.capacity());
+      for(auto &data : source) append(data);
+      return *this;
+    }
+
+    vector(const vector &source) : pool(nullptr), poolsize(0), objectsize(0) {
+      operator=(source);
+    }
+
+    //move
+    inline vector& operator=(vector &&source) {
+      reset();
+      pool = source.pool, poolsize = source.poolsize, objectsize = source.objectsize;
+      source.pool = nullptr, source.poolsize = 0, source.objectsize = 0;
+      return *this;
+    }
+
+    vector(vector &&source) : pool(nullptr), poolsize(0), objectsize(0) {
+      operator=(std::move(source));
+    }
+
+    //construction
+    vector() : pool(nullptr), poolsize(0), objectsize(0) {
+    }
+
+    vector(std::initializer_list<T> list) : pool(nullptr), poolsize(0), objectsize(0) {
+      for(auto &data : list) append(data);
+    }
+
+    ~vector() {
+      reset();
+    }
+  };
+
   //linear_vector
   //memory: O(capacity * 2)
   //
@@ -23,7 +138,7 @@ namespace nall {
   //if objects hold memory address references to themselves (introspection), a
   //valid copy constructor will be needed to keep pointers valid.
 
-  template<typename T> class linear_vector {
+  template<typename T> struct linear_vector {
   protected:
     T *pool;
     unsigned poolsize, objectsize;
@@ -160,7 +275,7 @@ namespace nall {
   //by guaranteeing that the base memory address of each objects never changes,
   //this avoids the need for an object to have a valid copy constructor.
 
-  template<typename T> class pointer_vector {
+  template<typename T> struct pointer_vector {
   protected:
     T **pool;
     unsigned poolsize, objectsize;

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/nes/Makefile

@@ -1,6 +1,6 @@
 nes_objects := nes-interface nes-system nes-scheduler nes-input
 nes_objects += nes-memory nes-cartridge nes-cpu nes-apu nes-ppu
-nes_objects += nes-cheat
+nes_objects += nes-cheat nes-video
 objects += $(nes_objects)
 
 obj/nes-interface.o: $(nes)/interface/interface.cpp $(call rwildcard,$(nes)/interface/)
@@ -13,3 +13,4 @@ obj/nes-cpu.o: $(nes)/cpu/cpu.cpp $(call rwildcard,$(nes)/cpu/)
 obj/nes-apu.o: $(nes)/apu/apu.cpp $(call rwildcard,$(nes)/apu/)
 obj/nes-ppu.o: $(nes)/ppu/ppu.cpp $(call rwildcard,$(nes)/ppu/)
 obj/nes-cheat.o: $(nes)/cheat/cheat.cpp $(call rwildcard,$(nes)/cheat/)
+obj/nes-video.o: $(nes)/video/video.cpp $(call rwildcard,$(nes)/video/)

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

@@ -1,4 +1,7 @@
 #include "bandai-fcg.cpp"
+#include "konami-vrc1.cpp"
+#include "konami-vrc2.cpp"
+#include "konami-vrc3.cpp"
 #include "konami-vrc4.cpp"
 #include "konami-vrc6.cpp"
 #include "konami-vrc7.cpp"
@@ -8,6 +11,7 @@
 #include "nes-exrom.cpp"
 #include "nes-fxrom.cpp"
 #include "nes-gxrom.cpp"
+#include "nes-hkrom.cpp"
 #include "nes-nrom.cpp"
 #include "nes-pxrom.cpp"
 #include "nes-sxrom.cpp"
@@ -82,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 = hex(board["prg"]["rom"].data);
+  prgram.size = hex(board["prg"]["ram"].data);
+  chrrom.size = hex(board["chr"]["rom"].data);
+  chrram.size = hex(board["chr"]["ram"].data);
 
   if(prgrom.size) prgrom.data = new uint8[prgrom.size]();
   if(prgram.size) prgram.data = new uint8[prgram.size]();
@@ -107,12 +111,15 @@ 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);
 
+  if(type == "KONAMI-VRC-1") return new KonamiVRC1(board, data, size);
+  if(type == "KONAMI-VRC-2") return new KonamiVRC2(board, data, size);
+  if(type == "KONAMI-VRC-3") return new KonamiVRC3(board, data, size);
   if(type == "KONAMI-VRC-4") return new KonamiVRC4(board, data, size);
   if(type == "KONAMI-VRC-6") return new KonamiVRC6(board, data, size);
   if(type == "KONAMI-VRC-7") return new KonamiVRC7(board, data, size);
@@ -137,6 +144,8 @@ Board* Board::load(const string &markup, const uint8_t *data, unsigned size) {
   if(type == "NES-GNROM"   ) return new NES_GxROM(board, data, size);
   if(type == "NES-MHROM"   ) return new NES_GxROM(board, data, size);
 
+  if(type == "NES-HKROM"   ) return new NES_HKROM(board, data, size);
+
   if(type == "NES-NROM-128") return new NES_NROM(board, data, size);
   if(type == "NES-NROM-256") return new NES_NROM(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

@@ -0,0 +1,40 @@
+struct KonamiVRC1 : Board {
+
+VRC1 vrc1;
+
+uint8 prg_read(unsigned addr) {
+  if(addr & 0x8000) return prgrom.read(vrc1.prg_addr(addr));
+  return cpu.mdr();
+}
+
+void prg_write(unsigned addr, uint8 data) {
+  if(addr & 0x8000) return vrc1.reg_write(addr, data);
+}
+
+uint8 chr_read(unsigned addr) {
+  if(addr & 0x2000) return ppu.ciram_read(vrc1.ciram_addr(addr));
+  return Board::chr_read(vrc1.chr_addr(addr));
+}
+
+void chr_write(unsigned addr, uint8 data) {
+  if(addr & 0x2000) return ppu.ciram_write(vrc1.ciram_addr(addr), data);
+  return Board::chr_write(vrc1.chr_addr(addr), data);
+}
+
+void power() {
+  vrc1.power();
+}
+
+void reset() {
+  vrc1.reset();
+}
+
+void serialize(serializer &s) {
+  Board::serialize(s);
+  vrc1.serialize(s);
+}
+
+KonamiVRC1(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), vrc1(*this) {
+}
+
+};

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

@@ -0,0 +1,57 @@
+struct KonamiVRC2 : Board {
+
+struct Settings {
+  struct Pinout {
+    unsigned a0;
+    unsigned a1;
+  } pinout;
+} settings;
+
+VRC2 vrc2;
+
+uint8 prg_read(unsigned addr) {
+  if(addr < 0x6000) return cpu.mdr();
+  if(addr < 0x8000) return vrc2.ram_read(addr);
+  return prgrom.read(vrc2.prg_addr(addr));
+}
+
+void prg_write(unsigned addr, uint8 data) {
+  if(addr < 0x6000) return;
+  if(addr < 0x8000) return vrc2.ram_write(addr, data);
+
+  bool a0 = (addr & settings.pinout.a0);
+  bool a1 = (addr & settings.pinout.a1);
+  addr &= 0xfff0;
+  addr |= (a0 << 0) | (a1 << 1);
+  return vrc2.reg_write(addr, data);
+}
+
+uint8 chr_read(unsigned addr) {
+  if(addr & 0x2000) return ppu.ciram_read(vrc2.ciram_addr(addr));
+  return Board::chr_read(vrc2.chr_addr(addr));
+}
+
+void chr_write(unsigned addr, uint8 data) {
+  if(addr & 0x2000) return ppu.ciram_write(vrc2.ciram_addr(addr), data);
+  return Board::chr_write(vrc2.chr_addr(addr), data);
+}
+
+void power() {
+  vrc2.power();
+}
+
+void reset() {
+  vrc2.reset();
+}
+
+void serialize(serializer &s) {
+  Board::serialize(s);
+  vrc2.serialize(s);
+}
+
+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

@@ -0,0 +1,57 @@
+struct KonamiVRC3 : Board {
+
+struct Settings {
+  bool mirror;  //0 = horizontal, 1 = vertical
+} settings;
+
+VRC3 vrc3;
+
+void main() {
+  vrc3.main();
+}
+
+uint8 prg_read(unsigned addr) {
+  if((addr & 0xe000) == 0x6000) return prgram.read(addr & 0x1fff);
+  if(addr & 0x8000) return prgrom.read(vrc3.prg_addr(addr));
+  return cpu.mdr();
+}
+
+void prg_write(unsigned addr, uint8 data) {
+  if((addr & 0xe000) == 0x6000) return prgram.write(addr & 0x1fff, data);
+  if(addr & 0x8000) return vrc3.reg_write(addr, data);
+}
+
+uint8 chr_read(unsigned addr) {
+  if(addr & 0x2000) {
+    if(settings.mirror == 0) addr = ((addr & 0x0800) >> 1) | (addr & 0x03ff);
+    return ppu.ciram_read(addr & 0x07ff);
+  }
+  return chrram.read(addr);
+}
+
+void chr_write(unsigned addr, uint8 data) {
+  if(addr & 0x2000) {
+    if(settings.mirror == 0) addr = ((addr & 0x0800) >> 1) | (addr & 0x03ff);
+    return ppu.ciram_write(addr & 0x07ff, data);
+  }
+  return chrram.write(addr, data);
+}
+
+void power() {
+  vrc3.power();
+}
+
+void reset() {
+  vrc3.reset();
+}
+
+void serialize(serializer &s) {
+  Board::serialize(s);
+  vrc3.serialize(s);
+}
+
+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;
 }
 

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

@@ -84,7 +84,7 @@ void serialize(serializer &s) {
   s.array(latch);
 }
 
-NES_FxROM(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
+NES_FxROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
   revision = Revision::FKROM;
 }
 

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

@@ -54,8 +54,8 @@ void serialize(serializer &s) {
   s.integer(chr_bank);
 }
 
-NES_GxROM(BML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size) {
-  settings.mirror = board["mirror"].value == "vertical" ? 1 : 0;
+NES_GxROM(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-hkrom.cpp

@@ -0,0 +1,48 @@
+struct NES_HKROM : Board {
+
+MMC6 mmc6;
+
+void main() {
+  mmc6.main();
+}
+
+uint8 prg_read(unsigned addr) {
+  if((addr & 0xf000) == 0x7000) return mmc6.ram_read(addr);
+  if(addr & 0x8000) return prgrom.read(mmc6.prg_addr(addr));
+  return cpu.mdr();
+}
+
+void prg_write(unsigned addr, uint8 data) {
+  if((addr & 0xf000) == 0x7000) return mmc6.ram_write(addr, data);
+  if(addr & 0x8000) return mmc6.reg_write(addr, data);
+}
+
+uint8 chr_read(unsigned addr) {
+  mmc6.irq_test(addr);
+  if(addr & 0x2000) return ppu.ciram_read(mmc6.ciram_addr(addr));
+  return Board::chr_read(mmc6.chr_addr(addr));
+}
+
+void chr_write(unsigned addr, uint8 data) {
+  mmc6.irq_test(addr);
+  if(addr & 0x2000) return ppu.ciram_write(mmc6.ciram_addr(addr), data);
+  return Board::chr_write(mmc6.chr_addr(addr), data);
+}
+
+void power() {
+  mmc6.power();
+}
+
+void reset() {
+  mmc6.reset();
+}
+
+void serialize(serializer &s) {
+  Board::serialize(s);
+  mmc6.serialize(s);
+}
+
+NES_HKROM(XML::Node &board, const uint8_t *data, unsigned size) : Board(board, data, size), mmc6(*this) {
+}
+
+};