Update to v075 release.

byuu says:

This release brings improved Super Game Boy emulation, the final SHA256
hashes for the DSP-(1,1B,2,3,4) and ST-(0010,0011) coprocessors, user
interface improvements, and major internal code restructuring.

Changelog (since v074):
- completely rewrote memory sub-system to support 1-byte granularity in
  XML mapping
- removed Memory inheritance and MMIO class completely, any address can
  be mapped to any function now
- SuperFX: removed SuperFXBus : Bus, now implemented manually
- SA-1: removed SA1Bus : Bus, now implemented manually
- entire bus mapping is now static, happens once on cartridge load
- as a result, read/write handlers now handle MMC mapping; slower
  average case, far faster worst case
- namespace memory is no more, RAM arrays are stored inside the chips
  they are owned by now
- GameBoy: improved CPU HALT emulation, fixes Zelda: Link's Awakening
  scrolling
- GameBoy: added serial emulation (cannot connect to another GB yet),
  fixes Shin Megami Tensei - Devichil
- GameBoy: improved LCD STAT emulation, fixes Sagaia
- ui: added fullscreen support (F11 key), video settings allows for
  three scale settings
- ui: fixed brightness, contrast, gamma, audio volume, input frequency
  values on program startup
- ui: since Qt is dead, config file becomes bsnes.cfg once again
- Super Game Boy: you can now load the BIOS without a game inserted to
  see a pretty white box
- ui-gameboy: can be built without SNES components now
- libsnes: now a UI target, compile with 'make ui=ui-libsnes'
- libsnes: added WRAM, APURAM, VRAM, OAM, CGRAM access (cheat search,
  etc)
- source: removed launcher/, as the Qt port is now gone
- source: Makefile restructuring to better support new ui targets
- source: lots of other internal code cleanup work

bsnes/Makefile

@@ -1,14 +1,15 @@
 include nall/Makefile
 snes := snes
+gameboy := gameboy
 profile := accuracy
-ui := ui-phoenix
+ui := ui
 
 # compiler
 c       := $(compiler) -std=gnu99
 cpp     := $(subst cc,++,$(compiler)) -std=gnu++0x
-flags   := -O3 -fomit-frame-pointer -I. -I$(snes)
+flags   := -O3 -fomit-frame-pointer -I.
 link    :=
-objects :=
+objects := libco
 
 # profile-guided instrumentation
 # flags += -fprofile-generate
@@ -45,38 +46,12 @@ compile = \
 
 all: build;
 
-include $(snes)/Makefile
+obj/libco.o: libco/libco.c libco/*
+
 include $(ui)/Makefile
 
-objects := $(patsubst %,obj/%.o,$(objects))
-
 # targets
-build: ui_build $(objects)
-ifeq ($(platform),osx)
-	test -d ../bsnes.app || mkdir -p ../bsnes.app/Contents/MacOS
-	$(strip $(cpp) -o ../bsnes.app/Contents/MacOS/bsnes $(objects) $(link))
-else
-	$(strip $(cpp) -o out/bsnes $(objects) $(link))
-endif
-
-install:
-ifeq ($(platform),x)
-	install -D -m 755 out/bsnes $(DESTDIR)$(prefix)/bin/bsnes
-	install -D -m 644 data/bsnes.png $(DESTDIR)$(prefix)/share/pixmaps/bsnes.png
-	install -D -m 644 data/bsnes.desktop $(DESTDIR)$(prefix)/share/applications/bsnes.desktop
-	test -d ~/.bsnes || mkdir ~/.bsnes
-	cp data/cheats.xml ~/.bsnes/cheats.xml
-	chmod 777 ~/.bsnes ~/.bsnes/cheats.xml
-endif
-
-uninstall:
-ifeq ($(platform),x)
-	rm $(DESTDIR)$(prefix)/bin/bsnes
-	rm $(DESTDIR)$(prefix)/share/pixmaps/bsnes.png
-	rm $(DESTDIR)$(prefix)/share/applications/bsnes.desktop
-endif
-
-clean: ui_clean
+clean:
 	-@$(call delete,obj/*.o)
 	-@$(call delete,obj/*.a)
 	-@$(call delete,obj/*.so)
@@ -90,6 +65,6 @@ clean: ui_clean
 	-@$(call delete,*.manifest)
 
 archive-all:
-	tar -cjf bsnes.tar.bz2 data launcher libco nall obj out phoenix ruby snes ui-phoenix ui-qt Makefile cc.bat clean.bat sync.sh
+	tar -cjf bsnes.tar.bz2 data gameboy libco nall obj out phoenix ruby snes ui ui-gameboy Makefile cc.bat clean.bat sync.sh
 
 help:;

bsnes/gameboy/Makefile

@@ -0,0 +1,12 @@
+gameboy_objects := gameboy-system gameboy-scheduler
+gameboy_objects += gameboy-memory gameboy-cartridge
+gameboy_objects += gameboy-cpu gameboy-apu gameboy-lcd
+objects += $(gameboy_objects)
+
+obj/gameboy-system.o: $(gameboy)/system/system.cpp $(call rwildcard,$(gameboy)/system/)
+obj/gameboy-scheduler.o: $(gameboy)/scheduler/scheduler.cpp $(call rwildcard,$(gameboy)/scheduler/)
+obj/gameboy-cartridge.o: $(gameboy)/cartridge/cartridge.cpp $(call rwildcard,$(gameboy)/cartridge/)
+obj/gameboy-memory.o: $(gameboy)/memory/memory.cpp $(call rwildcard,$(gameboy)/memory/)
+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/)

bsnes/gameboy/apu/apu.cpp

@@ -0,0 +1,85 @@
+#include <gameboy/gameboy.hpp>
+
+#define APU_CPP
+namespace GameBoy {
+
+#include "mmio/mmio.cpp"
+#include "serialization.cpp"
+APU apu;
+
+void APU::power() {
+  for(unsigned n = 0xff10; n <= 0xff3f; n++) bus.mmio[n] = this;
+
+  channel1.sweep_time = 0;
+  channel1.sweep_direction = 0;
+  channel1.sweep_shift = 0;
+
+  channel1.wave_pattern_duty = 0;
+  channel1.sound_length = 0;
+
+  channel1.initial_envelope_volume = 0;
+  channel1.envelope_direction = 0;
+  channel1.envelope_sweep = 0;
+
+  channel1.frequency = 0;
+  channel1.initialize = 0;
+  channel1.consecutive_selection = 0;
+
+  channel2.wave_pattern_duty = 0;
+  channel2.sound_length = 0;
+
+  channel2.initial_envelope_volume = 0;
+  channel2.envelope_direction = 0;
+  channel2.envelope_sweep = 0;
+
+  channel2.frequency = 0;
+  channel2.initialize = 0;
+  channel2.consecutive_selection = 0;
+
+  channel3.off = 0;
+
+  channel3.sound_length = 0;
+
+  channel3.output_level = 0;
+
+  channel3.frequency = 0;
+  channel3.initialize = 0;
+  channel3.consecutive_selection = 0;
+
+  for(unsigned n = 0; n < 16; n++) channel3.pattern[n] = 0;
+
+  channel4.sound_length = 0;
+
+  channel4.initial_envelope_volume = 0;
+  channel4.envelope_direction = 0;
+  channel4.envelope_sweep = 0;
+
+  channel4.shift_clock_frequency = 0;
+  channel4.counter_step_width = 0;
+  channel4.dividing_ratio = 0;
+
+  channel4.initialize = 0;
+  channel4.consecutive_selection = 0;
+
+  control.output_vin_to_so2 = 0;
+  control.so2_output_level = 0;
+  control.output_vin_to_so1 = 0;
+  control.so1_output_level = 0;
+
+  control.output_channel4_to_so2 = 0;
+  control.output_channel3_to_so2 = 0;
+  control.output_channel2_to_so2 = 0;
+  control.output_channel1_to_so2 = 0;
+  control.output_channel4_to_so1 = 0;
+  control.output_channel3_to_so1 = 0;
+  control.output_channel2_to_so1 = 0;
+  control.output_channel1_to_so1 = 0;
+
+  control.sound_on = 0;
+  control.channel4_on = 0;
+  control.channel3_on = 0;
+  control.channel2_on = 0;
+  control.channel1_on = 0;
+}
+
+}

bsnes/gameboy/apu/apu.hpp

@@ -0,0 +1,9 @@
+struct APU : Processor, MMIO {
+  #include "mmio/mmio.hpp"
+
+  void power();
+
+  void serialize(serializer&);
+};
+
+extern APU apu;

bsnes/gameboy/apu/mmio/mmio.cpp

@@ -0,0 +1,248 @@
+#ifdef APU_CPP
+
+uint8 APU::mmio_read(uint16 addr) {
+  if(addr == 0xff10) {  //NR10
+    return (channel1.sweep_time << 4)
+         | (channel1.sweep_direction << 3)
+         | (channel1.sweep_shift << 0);
+  }
+
+  if(addr == 0xff11) {  //NR11
+    return (channel1.wave_pattern_duty << 6);
+  }
+
+  if(addr == 0xff12) {  //NR12
+    return (channel1.initial_envelope_volume << 4)
+         | (channel1.envelope_direction << 3)
+         | (channel1.envelope_sweep << 0);
+  }
+
+  if(addr == 0xff14) {  //NR14
+    return (channel1.consecutive_selection << 6);
+  }
+
+  if(addr == 0xff16) {  //NR21
+    return (channel2.wave_pattern_duty << 6);
+  }
+
+  if(addr == 0xff17) {  //NR22
+    return (channel2.initial_envelope_volume << 4)
+         | (channel2.envelope_direction << 3)
+         | (channel2.envelope_sweep << 0);
+  }
+
+  if(addr == 0xff19) {  //NR24
+    return (channel2.consecutive_selection << 6);
+  }
+
+  if(addr == 0xff1a) {  //NR30
+    return (channel3.off << 7);
+  }
+
+  if(addr == 0xff1b) {  //NR31
+    return (channel3.sound_length << 0);
+  }
+
+  if(addr == 0xff1c) {  //NR32
+    return (channel3.output_level << 5);
+  }
+
+  if(addr == 0xff1e) {  //NR34
+    return (channel3.consecutive_selection << 6);
+  }
+
+  if(addr == 0xff20) {  //NR41
+    return (channel4.sound_length << 0);
+  }
+
+  if(addr == 0xff21) {  //NR42
+    return (channel4.initial_envelope_volume << 4)
+         | (channel4.envelope_direction << 3)
+         | (channel4.envelope_sweep << 0);
+  }
+
+  if(addr == 0xff22) {  //NR43
+    return (channel4.shift_clock_frequency << 4)
+         | (channel4.counter_step_width << 3)
+         | (channel4.dividing_ratio << 0);
+  }
+
+  if(addr == 0xff23) {  //NR44
+    return (channel4.consecutive_selection << 6);
+  }
+
+  if(addr == 0xff24) {  //NR50
+    return (control.output_vin_to_so2 << 7)
+         | (control.so2_output_level << 4)
+         | (control.output_vin_to_so1 << 3)
+         | (control.so1_output_level << 0);
+  }
+
+  if(addr == 0xff25) {  //NR51
+    return (control.output_channel4_to_so2 << 7)
+         | (control.output_channel3_to_so2 << 6)
+         | (control.output_channel2_to_so2 << 5)
+         | (control.output_channel1_to_so2 << 4)
+         | (control.output_channel4_to_so1 << 3)
+         | (control.output_channel3_to_so1 << 2)
+         | (control.output_channel2_to_so1 << 1)
+         | (control.output_channel1_to_so1 << 0);
+  }
+
+  if(addr == 0xff26) {  //NR52
+    return (control.sound_on << 7);
+  }
+
+  if(addr >= 0xff30 && addr <= 0xff3f) {
+    return channel3.pattern[addr & 15];
+  }
+
+  return 0x00;
+}
+
+void APU::mmio_write(uint16 addr, uint8 data) {
+  if(addr == 0xff10) {  //NR10
+    channel1.sweep_time = (data >> 4) & 7;
+    channel1.sweep_direction = data & 0x08;
+    channel1.sweep_shift = data & 0x07;
+    return;
+  }
+
+  if(addr == 0xff11) {  //NR11
+    channel1.wave_pattern_duty = (data >> 6) & 3;
+    channel1.sound_length = data & 0x3f;
+    return;
+  }
+
+  if(addr == 0xff12) {  //NR12
+    channel1.initial_envelope_volume = (data >> 4) & 15;
+    channel1.envelope_direction = data & 0x08;
+    channel1.envelope_sweep = data & 0x07;
+    return;
+  }
+
+  if(addr == 0xff13) {  //NR13
+    channel1.frequency = (channel1.frequency & 0x0700) | (data << 0);
+    return;
+  }
+
+  if(addr == 0xff14) {  //NR14
+    channel1.initialize = data & 0x80;
+    channel1.consecutive_selection = data & 0x40;
+    channel1.frequency = ((data & 7) << 8) | (channel1.frequency & 0x00ff);
+    return;
+  }
+
+  if(addr == 0xff16) {  //NR21
+    channel2.wave_pattern_duty = (data >> 6) & 3;
+    channel2.sound_length = data & 0x3f;
+    return;
+  }
+
+  if(addr == 0xff17) {  //NR22
+    channel2.initial_envelope_volume = (data >> 4) & 15;
+    channel2.envelope_direction = data & 0x08;
+    channel2.envelope_sweep = data & 0x07;
+    return;
+  }
+
+  if(addr == 0xff18) {  //NR23
+    channel2.frequency = (channel2.frequency & 0x0700) | (data << 0);
+    return;
+  }
+
+  if(addr == 0xff19) {  //NR24
+    channel2.initialize = data & 0x80;
+    channel2.consecutive_selection = data & 0x40;
+    channel2.frequency = ((data & 7) << 8) | (channel2.frequency & 0x00ff);
+    return;
+  }
+
+  if(addr == 0xff1a) {  //NR30
+    channel3.off = data & 0x80;
+    return;
+  }
+
+  if(addr == 0xff1b) {  //NR31
+    channel3.sound_length = data;
+    return;
+  }
+
+  if(addr == 0xff1c) {  //NR32
+    channel3.output_level = (data >> 5) & 3;
+    return;
+  }
+
+  if(addr == 0xff1d) {  //NR33
+    channel3.frequency = (channel3.frequency & 0x0700) | (data << 0);
+    return;
+  }
+
+  if(addr == 0xff1e) {  //NR34
+    channel3.initialize = data & 0x80;
+    channel3.consecutive_selection = data & 0x40;
+    channel3.frequency = ((data & 7) << 8) | (channel3.frequency & 0x00ff);
+    return;
+  }
+
+  if(addr == 0xff20) {  //NR41
+    channel4.sound_length = data & 0x3f;
+    return;
+  }
+
+  if(addr == 0xff21) {  //NR42
+    channel4.initial_envelope_volume = (data >> 3) & 15;
+    channel4.envelope_direction = data & 0x08;
+    channel4.envelope_sweep = data & 0x07;
+    return;
+  }
+
+  if(addr == 0xff22) {  //NR43
+    channel4.shift_clock_frequency = (data >> 4) & 15;
+    channel4.counter_step_width = data & 0x08;
+    channel4.dividing_ratio = data & 0x07;
+    return;
+  }
+
+  if(addr == 0xff23) {  //NR44
+    channel4.initialize = data & 0x80;
+    channel4.consecutive_selection = data & 0x40;
+    return;
+  }
+
+  if(addr == 0xff24) {  //NR50
+    control.output_vin_to_so2 = data & 0x80;
+    control.so2_output_level = (data >> 4) & 7;
+    control.output_vin_to_so1 = data & 0x08;
+    control.so1_output_level = (data >> 0) & 7;
+    return;
+  }
+
+  if(addr == 0xff25) {  //NR51
+    control.output_channel4_to_so2 = data & 0x80;
+    control.output_channel3_to_so2 = data & 0x40;
+    control.output_channel2_to_so2 = data & 0x20;
+    control.output_channel1_to_so2 = data & 0x10;
+    control.output_channel4_to_so1 = data & 0x08;
+    control.output_channel3_to_so1 = data & 0x04;
+    control.output_channel2_to_so1 = data & 0x02;
+    control.output_channel1_to_so1 = data & 0x01;
+    return;
+  }
+
+  if(addr == 0xff26) {  //NR52
+    control.sound_on = data & 0x80;
+    control.channel4_on = data & 0x08;
+    control.channel3_on = data & 0x04;
+    control.channel2_on = data & 0x02;
+    control.channel1_on = data & 0x01;
+    return;
+  }
+
+  if(addr >= 0xff30 && addr <= 0xff3f) {
+    channel3.pattern[addr & 15] = data;
+    return;
+  }
+}
+
+#endif

bsnes/gameboy/apu/mmio/mmio.hpp

@@ -0,0 +1,102 @@
+uint8 mmio_read(uint16 addr);
+void mmio_write(uint16 addr, uint8 data);
+
+struct Channel1 {  //tone and sweep
+  //$ff10  NR10
+  unsigned sweep_time;
+  bool sweep_direction;
+  unsigned sweep_shift;
+
+  //$ff11  NR11
+  unsigned wave_pattern_duty;
+  unsigned sound_length;
+
+  //$ff12  NR12
+  unsigned initial_envelope_volume;
+  bool envelope_direction;
+  unsigned envelope_sweep;
+
+  //$ff13,$ff14  NR13,NR14
+  unsigned frequency;
+  bool initialize;
+  bool consecutive_selection;
+} channel1;
+
+struct Channel2 {  //tone
+  //$ff16  NR21
+  unsigned wave_pattern_duty;
+  unsigned sound_length;
+
+  //$ff17  NR22
+  unsigned initial_envelope_volume;
+  bool envelope_direction;
+  unsigned envelope_sweep;
+
+  //$ff18,$ff19  NR23,NR24
+  unsigned frequency;
+  bool initialize;
+  bool consecutive_selection;
+} channel2;
+
+struct Channel3 {  //wave output
+  //$ff1a  NR30
+  bool off;
+
+  //$ff1b  NR31
+  unsigned sound_length;
+
+  //$ff1c  NR32
+  unsigned output_level;
+
+  //$ff1d,$ff1e  NR33,NR34
+  unsigned frequency;
+  bool initialize;
+  bool consecutive_selection;
+
+  //$ff30-ff3f
+  uint8 pattern[16];
+} channel3;
+
+struct Channel4 {  //noise
+  //$ff20  NR41
+  unsigned sound_length;
+
+  //$ff21  NR42
+  unsigned initial_envelope_volume;
+  bool envelope_direction;
+  unsigned envelope_sweep;
+
+  //$ff22  NR43
+  unsigned shift_clock_frequency;
+  bool counter_step_width;
+  unsigned dividing_ratio;
+
+  //$ff23  NR44
+  bool initialize;
+  bool consecutive_selection;
+} channel4;
+
+struct Control {
+  //$ff24  NR50
+  bool output_vin_to_so2;
+  unsigned so2_output_level;
+  bool output_vin_to_so1;
+  unsigned so1_output_level;
+
+  //$ff25  NR51
+  bool output_channel4_to_so2;
+  bool output_channel3_to_so2;
+  bool output_channel2_to_so2;
+  bool output_channel1_to_so2;
+  bool output_channel4_to_so1;
+  bool output_channel3_to_so1;
+  bool output_channel2_to_so1;
+  bool output_channel1_to_so1;
+
+  //$ff26  NR52
+  bool sound_on;
+  bool channel4_on;
+  bool channel3_on;
+  bool channel2_on;
+  bool channel1_on;
+} control;

bsnes/gameboy/apu/serialization.cpp

@@ -0,0 +1,6 @@
+#ifdef APU_CPP
+
+void APU::serialize(serializer &s) {
+}
+
+#endif

bsnes/gameboy/cartridge/cartridge.cpp

@@ -0,0 +1,148 @@
+#include <gameboy/gameboy.hpp>
+
+#include <nall/crc32.hpp>
+
+#define CARTRIDGE_CPP
+namespace GameBoy {
+
+#include "mbc0/mbc0.cpp"
+#include "mbc1/mbc1.cpp"
+#include "mbc2/mbc2.cpp"
+#include "mbc3/mbc3.cpp"
+#include "mbc5/mbc5.cpp"
+#include "mmm01/mmm01.cpp"
+#include "huc1/huc1.cpp"
+#include "huc3/huc3.cpp"
+#include "serialization.cpp"
+Cartridge cartridge;
+
+void Cartridge::load(const string &xml, 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;
+  info.rtc = false;
+  info.rumble = false;
+
+  info.romsize = 0;
+  info.ramsize = 0;
+
+  xml_element document = xml_parse(xml);
+  foreach(head, document.element) {
+    if(head.name == "cartridge") {
+      foreach(attr, head.attribute) {
+        if(attr.name == "mapper") {
+          if(attr.content == "none")  info.mapper = Mapper::MBC0;
+          if(attr.content == "MBC1")  info.mapper = Mapper::MBC1;
+          if(attr.content == "MBC2")  info.mapper = Mapper::MBC2;
+          if(attr.content == "MBC3")  info.mapper = Mapper::MBC3;
+          if(attr.content == "MBC5")  info.mapper = Mapper::MBC5;
+          if(attr.content == "MMM01") info.mapper = Mapper::MMM01;
+          if(attr.content == "HuC1")  info.mapper = Mapper::HuC1;
+          if(attr.content == "HuC3")  info.mapper = Mapper::HuC3;
+        }
+
+        if(attr.name == "rtc") info.rtc = (attr.content == "true" ? true : false);
+        if(attr.name == "rumble") info.rumble = (attr.content == "true" ? true : false);
+      }
+
+      foreach(elem, head.element) {
+        if(elem.name == "rom") {
+          foreach(attr, elem.attribute) {
+            if(attr.name == "size") info.romsize = hex(attr.content);
+          }
+        }
+
+        if(elem.name == "ram") {
+          info.ram = true;
+          foreach(attr, elem.attribute) {
+            if(attr.name == "size") info.ramsize = hex(attr.content);
+            if(attr.name == "battery") info.battery = (attr.content == "true" ? true : false);
+          }
+        }
+      }
+    }
+  }
+
+  ramdata = new uint8_t[ramsize = info.ramsize]();
+  loaded = true;
+}
+
+void Cartridge::unload() {
+  if(loaded == false) return;
+
+  if(romdata) { delete[] romdata; romdata = 0; }
+  if(ramdata) { delete[] ramdata; ramdata = 0; }
+  loaded = false;
+}
+
+uint8 Cartridge::rom_read(unsigned addr) {
+  if(addr >= romsize) addr %= romsize;
+  return romdata[addr];
+}
+
+void Cartridge::rom_write(unsigned addr, uint8 data) {
+  if(addr >= romsize) addr %= romsize;
+  romdata[addr] = data;
+}
+
+uint8 Cartridge::ram_read(unsigned addr) {
+  if(ramsize == 0) return 0x00;
+  if(addr >= ramsize) addr %= ramsize;
+  return ramdata[addr];
+}
+
+void Cartridge::ram_write(unsigned addr, uint8 data) {
+  if(ramsize == 0) return;
+  if(addr >= ramsize) addr %= ramsize;
+  ramdata[addr] = data;
+}
+
+void Cartridge::power() {
+  mbc0.power();
+  mbc1.power();
+  mbc2.power();
+  mbc3.power();
+  mbc5.power();
+  mmm01.power();
+  huc1.power();
+  huc3.power();
+  map();
+}
+
+void Cartridge::map() {
+  MMIO *mapper = 0;
+  switch(info.mapper) { default:
+    case Mapper::MBC0:  mapper = &mbc0;  break;
+    case Mapper::MBC1:  mapper = &mbc1;  break;
+    case Mapper::MBC2:  mapper = &mbc2;  break;
+    case Mapper::MBC3:  mapper = &mbc3;  break;
+    case Mapper::MBC5:  mapper = &mbc5;  break;
+    case Mapper::MMM01: mapper = &mmm01; break;
+    case Mapper::HuC1:  mapper = &huc1;  break;
+    case Mapper::HuC3:  mapper = &huc3;  break;
+  }
+
+  if(mapper) {
+    for(unsigned n = 0x0000; n <= 0x7fff; n++) bus.mmio[n] = mapper;
+    for(unsigned n = 0xa000; n <= 0xbfff; n++) bus.mmio[n] = mapper;
+  }
+}
+
+Cartridge::Cartridge() {
+  loaded = false;
+  romdata = 0;
+  ramdata = 0;
+}
+
+Cartridge::~Cartridge() {
+  unload();
+}
+
+}

bsnes/gameboy/cartridge/cartridge.hpp

@@ -0,0 +1,60 @@
+struct Cartridge : property<Cartridge> {
+  #include "mbc0/mbc0.hpp"
+  #include "mbc1/mbc1.hpp"
+  #include "mbc2/mbc2.hpp"
+  #include "mbc3/mbc3.hpp"
+  #include "mbc5/mbc5.hpp"
+  #include "mmm01/mmm01.hpp"
+  #include "huc1/huc1.hpp"
+  #include "huc3/huc3.hpp"
+
+  enum Mapper : unsigned {
+    MBC0,
+    MBC1,
+    MBC2,
+    MBC3,
+    MBC5,
+    MMM01,
+    HuC1,
+    HuC3,
+    Unknown,
+  };
+
+  struct Information {
+    string xml;
+
+    Mapper mapper;
+    bool ram;
+    bool battery;
+    bool rtc;
+    bool rumble;
+
+    unsigned romsize;
+    unsigned ramsize;
+  } info;
+
+  readonly<bool> loaded;
+
+  uint8_t *romdata;
+  unsigned romsize;
+
+  uint8_t *ramdata;
+  unsigned ramsize;
+
+  void load(const string &xml, const uint8_t *data, unsigned size);
+  void unload();
+
+  uint8 rom_read(unsigned addr);
+  void rom_write(unsigned addr, uint8 data);
+  uint8 ram_read(unsigned addr);
+  void ram_write(unsigned addr, uint8 data);
+
+  void power();
+  void map();
+
+  void serialize(serializer&);
+  Cartridge();
+  ~Cartridge();
+};
+
+extern Cartridge cartridge;

bsnes/gameboy/cartridge/huc1/huc1.cpp

@@ -0,0 +1,53 @@
+#ifdef CARTRIDGE_CPP
+
+uint8 Cartridge::HuC1::mmio_read(uint16 addr) {
+  if(within<0x0000, 0x3fff>(addr)) {
+    return cartridge.rom_read(addr);
+  }
+
+  if(within<0x4000, 0x7fff>(addr)) {
+    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;
+  }
+
+  return 0x00;
+}
+
+void Cartridge::HuC1::mmio_write(uint16 addr, uint8 data) {
+  if(within<0x0000, 0x1fff>(addr)) {
+    ram_enable = (data & 0x0f) == 0x0a;
+    return;
+  }
+
+  if(within<0x2000, 0x3fff>(addr)) {
+    rom_select = data;
+    return;
+  }
+
+  if(within<0x4000, 0x5fff>(addr)) {
+    ram_select = data;
+    return;
+  }
+
+  if(within<0x6000, 0x7fff>(addr)) {
+    //unknown purpose
+    return;
+  }
+
+  if(within<0xa000, 0xbfff>(addr)) {
+    if(ram_enable) cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
+    return;
+  }
+}
+
+void Cartridge::HuC1::power() {
+  ram_enable = false;
+  rom_select = 0x01;
+  ram_select = 0x00;
+}
+
+#endif

bsnes/gameboy/cartridge/huc1/huc1.hpp

@@ -0,0 +1,9 @@
+struct HuC1 : MMIO {
+  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);
+  void power();
+} huc1;

bsnes/gameboy/cartridge/huc3/huc3.cpp

@@ -0,0 +1,53 @@
+#ifdef CARTRIDGE_CPP
+
+uint8 Cartridge::HuC3::mmio_read(uint16 addr) {
+  if(within<0x0000, 0x3fff>(addr)) {
+    return cartridge.rom_read(addr);
+  }
+
+  if(within<0x4000, 0x7fff>(addr)) {
+    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;
+  }
+
+  return 0x00;
+}
+
+void Cartridge::HuC3::mmio_write(uint16 addr, uint8 data) {
+  if(within<0x0000, 0x1fff>(addr)) {
+    ram_enable = (data & 0x0f) == 0x0a;
+    return;
+  }
+
+  if(within<0x2000, 0x3fff>(addr)) {
+    rom_select = data;
+    return;
+  }
+
+  if(within<0x4000, 0x5fff>(addr)) {
+    ram_select = data;
+    return;
+  }
+
+  if(within<0x6000, 0x7fff>(addr)) {
+    //unknown purpose
+    return;
+  }
+
+  if(within<0xa000, 0xbfff>(addr)) {
+    if(ram_enable) cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
+    return;
+  }
+}
+
+void Cartridge::HuC3::power() {
+  ram_enable = false;
+  rom_select = 0x01;
+  ram_select = 0x00;
+}
+
+#endif

bsnes/gameboy/cartridge/huc3/huc3.hpp

@@ -0,0 +1,9 @@
+struct HuC3 : MMIO {
+  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);
+  void power();
+} huc3;

bsnes/gameboy/cartridge/mbc0/mbc0.cpp

@@ -0,0 +1,25 @@
+#ifdef CARTRIDGE_CPP
+
+uint8 Cartridge::MBC0::mmio_read(uint16 addr) {
+  if(within<0x0000, 0x7fff>(addr)) {
+    return cartridge.rom_read(addr);
+  }
+
+  if(within<0xa000, 0xbfff>(addr)) {
+    return cartridge.ram_read(addr & 0x1fff);
+  }
+
+  return 0x00;
+}
+
+void Cartridge::MBC0::mmio_write(uint16 addr, uint8 data) {
+  if(within<0xa000, 0xbfff>(addr)) {
+    cartridge.ram_write(addr & 0x1fff, data);
+    return;
+  }
+}
+
+void Cartridge::MBC0::power() {
+}
+
+#endif

bsnes/gameboy/cartridge/mbc0/mbc0.hpp

@@ -0,0 +1,5 @@
+struct MBC0 : MMIO {
+  uint8 mmio_read(uint16 addr);
+  void mmio_write(uint16 addr, uint8 data);
+  void power();
+} mbc0;

bsnes/gameboy/cartridge/mbc1/mbc1.cpp

@@ -0,0 +1,70 @@
+#ifdef CARTRIDGE_CPP
+
+uint8 Cartridge::MBC1::mmio_read(uint16 addr) {
+  if(within<0x0000, 0x3fff>(addr)) {
+    return cartridge.rom_read(addr);
+  }
+
+  if(within<0x4000, 0x7fff>(addr)) {
+    if(mode_select == 0) {
+      return cartridge.rom_read((ram_select << 19) | (rom_select << 14) | (addr & 0x3fff));
+    } else {
+      return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
+    }
+  }
+
+  if(within<0xa000, 0xbfff>(addr)) {
+    if(ram_enable) {
+      if(mode_select == 0) {
+        return cartridge.ram_read(addr & 0x1fff);
+      } else {
+        return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
+      }
+    }
+    return 0x00;
+  }
+
+  return 0x00;
+}
+
+void Cartridge::MBC1::mmio_write(uint16 addr, uint8 data) {
+  if(within<0x0000, 0x1fff>(addr)) {
+    ram_enable = (data & 0x0f) == 0x0a;
+    return;
+  }
+
+  if(within<0x2000, 0x3fff>(addr)) {
+    rom_select = (data & 0x1f) + ((data & 0x1f) == 0);
+    return;
+  }
+
+  if(within<0x4000, 0x5fff>(addr)) {
+    ram_select = data & 0x03;
+    return;
+  }
+
+  if(within<0x6000, 0x7fff>(addr)) {
+    mode_select = data & 0x01;
+    return;
+  }
+
+  if(within<0xa000, 0xbfff>(addr)) {
+    if(ram_enable) {
+      if(mode_select == 0) {
+        cartridge.ram_write(addr & 0x1fff, data);
+      } else {
+        cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
+      }
+    }
+    return;
+  }
+}
+
+void Cartridge::MBC1::power() {
+  ram_enable = false;
+  rom_select = 0x01;
+  ram_select = 0x00;
+  mode_select = 0;
+}
+
+#endif

bsnes/gameboy/cartridge/mbc1/mbc1.hpp

@@ -0,0 +1,10 @@
+struct MBC1 : MMIO {
+  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);
+  void power();
+} mbc1;

bsnes/gameboy/cartridge/mbc2/mbc2.cpp

@@ -0,0 +1,42 @@
+#ifdef CARTRIDGE_CPP
+
+uint8 Cartridge::MBC2::mmio_read(uint16 addr) {
+  if(within<0x0000, 0x3fff>(addr)) {
+    return cartridge.rom_read(addr);
+  }
+
+  if(within<0x4000, 0x7fff>(addr)) {
+    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
+  }
+
+  if(within<0xa000, 0xa1ff>(addr)) {
+    if(ram_enable) return cartridge.ram_read(addr & 0x1ff);
+    return 0x00;
+  }
+
+  return 0x00;
+}
+
+void Cartridge::MBC2::mmio_write(uint16 addr, uint8 data) {
+  if(within<0x0000, 0x1fff>(addr)) {
+    if(!(addr & 0x0100)) ram_enable = (data & 0x0f) == 0x0a;
+    return;
+  }
+
+  if(within<0x2000, 0x3fff>(addr)) {
+    if( (addr & 0x0100)) rom_select = (data & 0x0f) + ((data & 0x0f) == 0);
+    return;
+  }
+
+  if(within<0xa000, 0xa1ff>(addr)) {
+    if(ram_enable) cartridge.ram_write(addr & 0x1ff, data & 0x0f);
+    return;
+  }
+}
+
+void Cartridge::MBC2::power() {
+  ram_enable = false;
+  rom_select = 0x01;
+}
+
+#endif

bsnes/gameboy/cartridge/mbc2/mbc2.hpp

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

bsnes/gameboy/cartridge/mbc3/mbc3.cpp

@@ -0,0 +1,120 @@
+#ifdef CARTRIDGE_CPP
+
+void Cartridge::MBC3::second() {
+  if(rtc_halt == false) {
+    if(++rtc_second >= 60) {
+      rtc_second = 0;
+      if(++rtc_minute >= 60) {
+        rtc_minute = 0;
+        if(++rtc_hour >= 24) {
+          rtc_hour = 0;
+          if(++rtc_day >= 512) {
+            rtc_day = 0;
+            rtc_day_carry = true;
+          }
+        }
+      }
+    }
+  }
+}
+
+uint8 Cartridge::MBC3::mmio_read(uint16 addr) {
+  if(within<0x0000, 0x3fff>(addr)) {
+    return cartridge.rom_read(addr);
+  }
+
+  if(within<0x4000, 0x7fff>(addr)) {
+    return cartridge.rom_read((rom_select << 14) | (addr & 0x3fff));
+  }
+
+  if(within<0xa000, 0xbfff>(addr)) {
+    if(ram_enable) {
+      if(ram_select >= 0x00 && ram_select <= 0x03) {
+        return cartridge.ram_read((ram_select << 13) | (addr & 0x1fff));
+      }
+      if(ram_select == 0x08) return rtc_latch_second;
+      if(ram_select == 0x09) return rtc_latch_minute;
+      if(ram_select == 0x0a) return rtc_latch_hour;
+      if(ram_select == 0x0b) return rtc_latch_day;
+      if(ram_select == 0x0c) return (rtc_latch_day_carry << 7) | (rtc_latch_day >> 8);
+    }
+    return 0x00;
+  }
+
+  return 0x00;
+}
+
+void Cartridge::MBC3::mmio_write(uint16 addr, uint8 data) {
+  if(within<0x0000, 0x1fff>(addr)) {
+    ram_enable = (data & 0x0f) == 0x0a;
+    return;
+  }
+
+  if(within<0x2000, 0x3fff>(addr)) {
+    rom_select = (data & 0x7f) + ((data & 0x7f) == 0);
+    return;
+  }
+
+  if(within<0x4000, 0x5fff>(addr)) {
+    ram_select = data;
+    return;
+  }
+
+  if(within<0x6000, 0x7fff>(addr)) {
+    if(rtc_latch == 0 && data == 1) {
+      rtc_latch_second = rtc_second;
+      rtc_latch_minute = rtc_minute;
+      rtc_latch_hour = rtc_hour;
+      rtc_latch_day = rtc_day;
+      rtc_latch_day_carry = rtc_day_carry;
+    }
+    rtc_latch = data;
+    return;
+  }
+
+  if(within<0xa000, 0xbfff>(addr)) {
+    if(ram_enable) {
+      if(ram_select >= 0x00 && ram_select <= 0x03) {
+        cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
+      } else if(ram_select == 0x08) {
+        if(data >= 60) data = 0;
+        rtc_second = data;
+      } else if(ram_select == 0x09) {
+        if(data >= 60) data = 0;
+        rtc_minute = data;
+      } else if(ram_select == 0x0a) {
+        if(data >= 24) data = 0;
+        rtc_hour = data;
+      } else if(ram_select == 0x0b) {
+        rtc_day = (rtc_day & 0x0100) | data;
+      } else if(ram_select == 0x0c) {
+        rtc_day = ((data & 1) << 8) | (rtc_day & 0xff);
+        rtc_halt = data & 0x40;
+        rtc_day_carry = data & 0x80;
+      }
+    }
+    return;
+  }
+}
+
+void Cartridge::MBC3::power() {
+  ram_enable = false;
+  rom_select = 0x01;
+  ram_select = 0x00;
+  rtc_latch = 0;
+
+  rtc_halt = true;
+  rtc_second = 0;
+  rtc_minute = 0;
+  rtc_hour = 0;
+  rtc_day = 0;
+  rtc_day_carry = false;
+
+  rtc_latch_second = 0;
+  rtc_latch_minute = 0;
+  rtc_latch_hour = 0;
+  rtc_latch_day = 0;
+  rtc_latch_day_carry = false;
+}
+
+#endif

bsnes/gameboy/cartridge/mbc3/mbc3.hpp

@@ -0,0 +1,24 @@
+struct MBC3 : MMIO {
+  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;
+  unsigned rtc_minute;
+  unsigned rtc_hour;
+  unsigned rtc_day;
+  bool rtc_day_carry;
+
+  unsigned rtc_latch_second;
+  unsigned rtc_latch_minute;
+  unsigned rtc_latch_hour;
+  unsigned rtc_latch_day;
+  unsigned rtc_latch_day_carry;
+
+  void second();
+  uint8 mmio_read(uint16 addr);
+  void mmio_write(uint16 addr, uint8 data);
+  void power();
+} mbc3;

bsnes/gameboy/cartridge/mbc5/mbc5.cpp

@@ -0,0 +1,53 @@
+#ifdef CARTRIDGE_CPP
+
+uint8 Cartridge::MBC5::mmio_read(uint16 addr) {
+  if(within<0x0000, 0x3fff>(addr)) {
+    return cartridge.rom_read(addr);
+  }
+
+  if(within<0x4000, 0x7fff>(addr)) {
+    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;
+  }
+
+  return 0x00;
+}
+
+void Cartridge::MBC5::mmio_write(uint16 addr, uint8 data) {
+  if(within<0x0000, 0x1fff>(addr)) {
+    ram_enable = (data & 0x0f) == 0x0a;
+    return;
+  }
+
+  if(within<0x2000, 0x2fff>(addr)) {
+    rom_select = (rom_select & 0x0100) | data;
+    return;
+  }
+
+  if(within<0x3000, 0x3fff>(addr)) {
+    rom_select = ((data & 1) << 8) | (rom_select & 0x00ff);
+    return;
+  }
+
+  if(within<0x4000, 0x5fff>(addr)) {
+    ram_select = data & 0x0f;
+    return;
+  }
+
+  if(within<0xa000, 0xbfff>(addr)) {
+    if(ram_enable) cartridge.ram_write((ram_select << 13) | (addr & 0x1fff), data);
+    return;
+  }
+}
+
+void Cartridge::MBC5::power() {
+  ram_enable = false;
+  rom_select = 0x001;
+  ram_select = 0x00;
+}
+
+#endif

bsnes/gameboy/cartridge/mbc5/mbc5.hpp

@@ -0,0 +1,9 @@
+struct MBC5 : MMIO {
+  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);
+  void power();
+} mbc5;

bsnes/gameboy/cartridge/mmm01/mmm01.cpp

@@ -0,0 +1,65 @@
+#ifdef CARTRIDGE_CPP
+
+uint8 Cartridge::MMM01::mmio_read(uint16 addr) {
+  if(within<0x0000, 0x7fff>(addr)) {
+    if(rom_mode == 0) return cartridge.rom_read(addr);
+  }
+
+  if(within<0x0000, 0x3fff>(addr)) {
+    return cartridge.rom_read(0x8000 + (rom_base << 14) + (addr & 0x3fff));
+  }
+
+  if(within<0x4000, 0x7fff>(addr)) {
+    return cartridge.rom_read(0x8000 + (rom_base << 14) + (rom_select << 14) + (addr & 0x3fff));
+  }
+
+  if(within<0xa000, 0xbfff>(addr)) {
+    if(ram_enable) return cartridge.ram_read((ram_select << 13) + (addr & 0x1fff));
+    return 0x00;
+  }
+
+  return 0x00;
+}
+
+void Cartridge::MMM01::mmio_write(uint16 addr, uint8 data) {
+  if(within<0x0000, 0x1fff>(addr)) {
+    if(rom_mode == 0) {
+      rom_mode = 1;
+    } else {
+      ram_enable = (data & 0x0f) == 0x0a;
+    }
+  }
+
+  if(within<0x2000, 0x3fff>(addr)) {
+    if(rom_mode == 0) {
+      rom_base = data & 0x3f;
+    } else {
+      rom_select = data;
+    }
+  }
+
+  if(within<0x4000, 0x5fff>(addr)) {
+    if(rom_mode == 1) {
+      ram_select = data;
+    }
+  }
+
+  if(within<0x6000, 0x7fff>(addr)) {
+    //unknown purpose
+  }
+
+  if(within<0xa000, 0xbfff>(addr)) {
+    if(ram_enable) cartridge.ram_write((ram_select << 13) + (addr & 0x1fff), data);
+  }
+}
+
+void Cartridge::MMM01::power() {
+  rom_mode = 0;
+  rom_base = 0x00;
+
+  ram_enable = false;
+  rom_select = 0x01;
+  ram_select = 0x00;
+}
+
+#endif

bsnes/gameboy/cartridge/mmm01/mmm01.hpp

@@ -0,0 +1,12 @@
+struct MMM01 : MMIO {
+  bool rom_mode;
+  uint8 rom_base;
+
+  bool ram_enable;
+  uint8 rom_select;
+  uint8 ram_select;
+
+  uint8 mmio_read(uint16 addr);
+  void mmio_write(uint16 addr, uint8 data);
+  void power();
+} mmm01;

bsnes/gameboy/cartridge/serialization.cpp

@@ -0,0 +1,52 @@
+#ifdef CARTRIDGE_CPP
+
+void Cartridge::serialize(serializer &s) {
+  if(info.battery) s.array(ramdata, ramsize);
+
+  s.integer(mbc1.ram_enable);
+  s.integer(mbc1.rom_select);
+  s.integer(mbc1.ram_select);
+  s.integer(mbc1.mode_select);
+
+  s.integer(mbc2.ram_enable);
+  s.integer(mbc2.rom_select);
+
+  s.integer(mbc3.ram_enable);
+  s.integer(mbc3.rom_select);
+  s.integer(mbc3.ram_select);
+  s.integer(mbc3.rtc_latch);
+
+  s.integer(mbc3.rtc_halt);
+  s.integer(mbc3.rtc_second);
+  s.integer(mbc3.rtc_minute);
+  s.integer(mbc3.rtc_hour);
+  s.integer(mbc3.rtc_day);
+  s.integer(mbc3.rtc_day_carry);
+
+  s.integer(mbc3.rtc_latch_second);
+  s.integer(mbc3.rtc_latch_minute);
+  s.integer(mbc3.rtc_latch_hour);
+  s.integer(mbc3.rtc_latch_day);
+  s.integer(mbc3.rtc_latch_day_carry);
+
+  s.integer(mbc5.ram_enable);
+  s.integer(mbc5.rom_select);
+  s.integer(mbc5.ram_select);
+
+  s.integer(mmm01.rom_mode);
+  s.integer(mmm01.rom_base);
+
+  s.integer(mmm01.ram_enable);
+  s.integer(mmm01.rom_select);
+  s.integer(mmm01.ram_select);
+
+  s.integer(huc1.ram_enable);
+  s.integer(huc1.rom_select);
+  s.integer(huc1.ram_select);
+
+  s.integer(huc3.ram_enable);
+  s.integer(huc3.rom_select);
+  s.integer(huc3.ram_select);
+}
+
+#endif

bsnes/gameboy/cpu/core/core.cpp

@@ -0,0 +1,674 @@
+#ifdef CPU_CPP
+
+#include "table.cpp"
+#include "disassembler.cpp"
+
+void CPU::op_xx() {
+}
+
+void CPU::op_cb() {
+  uint8 opcode = op_read(r[PC]++);
+  (this->*opcode_table_cb[opcode])();
+}
+
+//8-bit load commands
+
+template<unsigned x, unsigned y> void CPU::op_ld_r_r() {
+  r[x] = r[y];
+}
+
+template<unsigned x> void CPU::op_ld_r_n() {
+  r[x] = op_read(r[PC]++);
+}
+
+template<unsigned x> void CPU::op_ld_r_hl() {
+  r[x] = op_read(r[HL]);
+}
+
+template<unsigned x> void CPU::op_ld_hl_r() {
+  op_write(r[HL], r[x]);
+}
+
+void CPU::op_ld_hl_n() {
+  op_write(r[HL], op_read(r[PC]++));
+}
+
+template<unsigned x> void CPU::op_ld_a_rr() {
+  r[A] = op_read(r[x]);
+}
+
+void CPU::op_ld_a_nn() {
+  uint8 lo = op_read(r[PC]++);
+  uint8 hi = op_read(r[PC]++);
+  r[A] = op_read((hi << 8) | (lo << 0));
+}
+
+template<unsigned x> void CPU::op_ld_rr_a() {
+  op_write(r[x], r[A]);
+}
+
+void CPU::op_ld_nn_a() {
+  uint8 lo = op_read(r[PC]++);
+  uint8 hi = op_read(r[PC]++);
+  op_write((hi << 8) | (lo << 0), r[A]);
+}
+
+void CPU::op_ld_a_ffn() {
+  r[A] = op_read(0xff00 + op_read(r[PC]++));
+}
+
+void CPU::op_ld_ffn_a() {
+  op_write(0xff00 + op_read(r[PC]++), r[A]);
+}
+
+void CPU::op_ld_a_ffc() {
+  r[A] = op_read(0xff00 + r[C]);
+}
+
+void CPU::op_ld_ffc_a() {
+  op_write(0xff00 + r[C], r[A]);
+}
+
+void CPU::op_ldi_hl_a() {
+  op_write(r[HL], r[A]);
+  r[HL]++;
+}
+
+void CPU::op_ldi_a_hl() {
+  r[A] = op_read(r[HL]);
+  r[HL]++;
+}
+
+void CPU::op_ldd_hl_a() {
+  op_write(r[HL], r[A]);
+  r[HL]--;
+}
+
+void CPU::op_ldd_a_hl() {
+  r[A] = op_read(r[HL]);
+  r[HL]--;
+}
+
+//16-bit load commands
+
+template<unsigned x> void CPU::op_ld_rr_nn() {
+  r[x]  = op_read(r[PC]++) << 0;
+  r[x] |= op_read(r[PC]++) << 8;
+}
+
+void CPU::op_ld_nn_sp() {
+  uint16 addr = op_read(r[PC]++) << 0;
+  addr |= op_read(r[PC]++) << 8;
+  op_write(addr + 0, r[SP] >> 0);
+  op_write(addr + 1, r[SP] >> 8);
+}
+
+void CPU::op_ld_sp_hl() {
+  r[SP] = r[HL];
+  op_io();
+}
+
+template<unsigned x> void CPU::op_push_rr() {
+  op_write(--r[SP], r[x] >> 8);
+  op_write(--r[SP], r[x] >> 0);
+  op_io();
+}
+
+template<unsigned x> void CPU::op_pop_rr() {
+  r[x]  = op_read(r[SP]++) << 0;
+  r[x] |= op_read(r[SP]++) << 8;
+}
+
+//8-bit arithmetic commands
+
+void CPU::opi_add_a(uint8 x) {
+  uint16 rh = r[A] + x;
+  uint16 rl = (r[A] & 0x0f) + (x & 0x0f);
+  r[A] = rh;
+  r.f.z = (uint8)rh == 0;
+  r.f.n = 0;
+  r.f.h = rl > 0x0f;
+  r.f.c = rh > 0xff;
+}
+
+template<unsigned x> void CPU::op_add_a_r() { opi_add_a(r[x]); }
+void CPU::op_add_a_n() { opi_add_a(op_read(r[PC]++)); }
+void CPU::op_add_a_hl() { opi_add_a(op_read(r[HL])); }
+
+void CPU::opi_adc_a(uint8 x) {
+  uint16 rh = r[A] + x + r.f.c;
+  uint16 rl = (r[A] & 0x0f) + (x & 0x0f) + r.f.c;
+  r[A] = rh;
+  r.f.z = (uint8)rh == 0;
+  r.f.n = 0;
+  r.f.h = rl > 0x0f;
+  r.f.c = rh > 0xff;
+}
+
+template<unsigned x> void CPU::op_adc_a_r() { opi_adc_a(r[x]); }
+void CPU::op_adc_a_n() { opi_adc_a(op_read(r[PC]++)); }
+void CPU::op_adc_a_hl() { opi_adc_a(op_read(r[HL])); }
+
+void CPU::opi_sub_a(uint8 x) {
+  uint16 rh = r[A] - x;
+  uint16 rl = (r[A] & 0x0f) - (x & 0x0f);
+  r[A] = rh;
+  r.f.z = (uint8)rh == 0;
+  r.f.n = 1;
+  r.f.h = rl > 0x0f;
+  r.f.c = rh > 0xff;
+}
+
+template<unsigned x> void CPU::op_sub_a_r() { opi_sub_a(r[x]); }
+void CPU::op_sub_a_n() { opi_sub_a(op_read(r[PC]++)); }
+void CPU::op_sub_a_hl() { opi_sub_a(op_read(r[HL])); }
+
+void CPU::opi_sbc_a(uint8 x) {
+  uint16 rh = r[A] - x - r.f.c;
+  uint16 rl = (r[A] & 0x0f) - (x & 0x0f) - r.f.c;
+  r[A] = rh;
+  r.f.z = (uint8)rh == 0;
+  r.f.n = 1;
+  r.f.h = rl > 0x0f;
+  r.f.c = rh > 0xff;
+}
+
+template<unsigned x> void CPU::op_sbc_a_r() { opi_sbc_a(r[x]); }
+void CPU::op_sbc_a_n() { opi_sbc_a(op_read(r[PC]++)); }
+void CPU::op_sbc_a_hl() { opi_sbc_a(op_read(r[HL])); }
+
+void CPU::opi_and_a(uint8 x) {
+  r[A] &= x;
+  r.f.z = r[A] == 0;
+  r.f.n = 0;
+  r.f.h = 1;
+  r.f.c = 0;
+}
+
+template<unsigned x> void CPU::op_and_a_r() { opi_and_a(r[x]); }
+void CPU::op_and_a_n() { opi_and_a(op_read(r[PC]++)); }
+void CPU::op_and_a_hl() { opi_and_a(op_read(r[HL])); }
+
+void CPU::opi_xor_a(uint8 x) {
+  r[A] ^= x;
+  r.f.z = r[A] == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = 0;
+}
+
+template<unsigned x> void CPU::op_xor_a_r() { opi_xor_a(r[x]); }
+void CPU::op_xor_a_n() { opi_xor_a(op_read(r[PC]++)); }
+void CPU::op_xor_a_hl() { opi_xor_a(op_read(r[HL])); }
+
+void CPU::opi_or_a(uint8 x) {
+  r[A] |= x;
+  r.f.z = r[A] == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = 0;
+}
+
+template<unsigned x> void CPU::op_or_a_r() { opi_or_a(r[x]); }
+void CPU::op_or_a_n() { opi_or_a(op_read(r[PC]++)); }
+void CPU::op_or_a_hl() { opi_or_a(op_read(r[HL])); }
+
+void CPU::opi_cp_a(uint8 x) {
+  uint16 rh = r[A] - x;
+  uint16 rl = (r[A] & 0x0f) - (x & 0x0f);
+  r.f.z = (uint8)rh == 0;
+  r.f.n = 1;
+  r.f.h = rl > 0x0f;
+  r.f.c = rh > 0xff;
+}
+
+template<unsigned x> void CPU::op_cp_a_r() { opi_cp_a(r[x]); }
+void CPU::op_cp_a_n() { opi_cp_a(op_read(r[PC]++)); }
+void CPU::op_cp_a_hl() { opi_cp_a(op_read(r[HL])); }
+
+template<unsigned x> void CPU::op_inc_r() {
+  r[x]++;
+  r.f.z = r[x] == 0;
+  r.f.n = 0;
+  r.f.h = (r[x] & 0x0f) == 0x00;
+}
+
+void CPU::op_inc_hl() {
+  uint8 n = op_read(r[HL]);
+  op_write(r[HL], ++n);
+  r.f.z = n == 0;
+  r.f.n = 0;
+  r.f.h = (n & 0x0f) == 0x00;
+}
+
+template<unsigned x> void CPU::op_dec_r() {
+  r[x]--;
+  r.f.z = r[x] == 0;
+  r.f.n = 1;
+  r.f.h = (r[x] & 0x0f) == 0x0f;
+}
+
+void CPU::op_dec_hl() {
+  uint8 n = op_read(r[HL]);
+  op_write(r[HL], --n);
+  r.f.z = n == 0;
+  r.f.n = 1;
+  r.f.h = (n & 0x0f) == 0x0f;
+}
+
+void CPU::op_daa() {
+  uint16 a = r[A];
+  if(r.f.n == 0) {
+    if(r.f.h || (a & 0x0f) > 0x09) a += 0x06;
+    if(r.f.c || (a       ) > 0x9f) a += 0x60;
+  } else {
+    if(r.f.h) {
+      a -= 0x06;
+      if(r.f.c == 0) a &= 0xff;
+    }
+    if(r.f.c) a -= 0x60;
+  }
+  r[A] = a;
+  r.f.z = r[A] == 0;
+  r.f.h = 0;
+  r.f.c |= a & 0x100;
+}
+
+void CPU::op_cpl() {
+  r[A] ^= 0xff;
+  r.f.n = 1;
+  r.f.h = 1;
+}
+
+//16-bit arithmetic commands
+
+template<unsigned x> void CPU::op_add_hl_rr() {
+  op_io();
+  uint32 rb = (r[HL] + r[x]);
+  uint32 rn = (r[HL] & 0xfff) + (r[x] & 0xfff);
+  r[HL] = rb;
+  r.f.n = 0;
+  r.f.h = rn > 0x0fff;
+  r.f.c = rb > 0xffff;
+}
+
+template<unsigned x> void CPU::op_inc_rr() {
+  op_io();
+  r[x]++;
+}
+
+template<unsigned x> void CPU::op_dec_rr() {
+  op_io();
+  r[x]--;
+}
+
+void CPU::op_add_sp_n() {
+  op_io();
+  op_io();
+  signed n = (int8)op_read(r[PC]++);
+  r.f.z = 0;
+  r.f.n = 0;
+  r.f.h = ((r[SP] & 0x0f) + (n & 0x0f)) > 0x0f;
+  r.f.c = ((r[SP] & 0xff) + (n & 0xff)) > 0xff;
+  r[SP] += n;
+}
+
+void CPU::op_ld_hl_sp_n() {
+  op_io();
+  signed n = (int8)op_read(r[PC]++);
+  r.f.z = 0;
+  r.f.n = 0;
+  r.f.h = ((r[SP] & 0x0f) + (n & 0x0f)) > 0x0f;
+  r.f.c = ((r[SP] & 0xff) + (n & 0xff)) > 0xff;
+  r[HL] = r[SP] + n;
+}
+
+//rotate/shift commands
+
+void CPU::op_rlca() {
+  r[A] = (r[A] << 1) | (r[A] >> 7);
+  r.f.z = 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = r[A] & 0x01;
+}
+
+void CPU::op_rla() {
+  bool c = r[A] & 0x80;
+  r[A] = (r[A] << 1) | (r.f.c << 0);
+  r.f.z = 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+void CPU::op_rrca() {
+  r[A] = (r[A] >> 1) | (r[A] << 7);
+  r.f.z = 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = r[A] & 0x80;
+}
+
+void CPU::op_rra() {
+  bool c = r[A] & 0x01;
+  r[A] = (r[A] >> 1) | (r.f.c << 7);
+  r.f.z = 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+template<unsigned x> void CPU::op_rlc_r() {
+  r[x] = (r[x] << 1) | (r[x] >> 7);
+  r.f.z = r[x] == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = r[x] & 0x01;
+}
+
+void CPU::op_rlc_hl() {
+  uint8 n = op_read(r[HL]);
+  n = (n << 1) | (n >> 7);
+  op_write(r[HL], n);
+  r.f.z = n == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = n & 0x01;
+}
+
+template<unsigned x> void CPU::op_rl_r() {
+  bool c = r[x] & 0x80;
+  r[x] = (r[x] << 1) | (r.f.c << 0);
+  r.f.z = r[x] == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+void CPU::op_rl_hl() {
+  uint8 n = op_read(r[HL]);
+  bool c = n & 0x80;
+  n = (n << 1) | (r.f.c << 0);
+  op_write(r[HL], n);
+  r.f.z = n == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+template<unsigned x> void CPU::op_rrc_r() {
+  r[x] = (r[x] >> 1) | (r[x] << 7);
+  r.f.z = r[x] == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = r[x] & 0x80;
+}
+
+void CPU::op_rrc_hl() {
+  uint8 n = op_read(r[HL]);
+  n = (n >> 1) | (n << 7);
+  op_write(r[HL], n);
+  r.f.z = n == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = n & 0x80;
+}
+
+template<unsigned x> void CPU::op_rr_r() {
+  bool c = r[x] & 0x01;
+  r[x] = (r[x] >> 1) | (r.f.c << 7);
+  r.f.z = r[x] == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+void CPU::op_rr_hl() {
+  uint8 n = op_read(r[HL]);
+  bool c = n & 0x01;
+  n = (n >> 1) | (r.f.c << 7);
+  op_write(r[HL], n);
+  r.f.z = n == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+template<unsigned x> void CPU::op_sla_r() {
+  bool c = r[x] & 0x80;
+  r[x] <<= 1;
+  r.f.z = r[x] == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+void CPU::op_sla_hl() {
+  uint8 n = op_read(r[HL]);
+  bool c = n & 0x80;
+  n <<= 1;
+  op_write(r[HL], n);
+  r.f.z = n == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+template<unsigned x> void CPU::op_swap_r() {
+  r[x] = (r[x] << 4) | (r[x] >> 4);
+  r.f.z = r[x] == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = 0;
+}
+
+void CPU::op_swap_hl() {
+  uint8 n = op_read(r[HL]);
+  n = (n << 4) | (n >> 4);
+  op_write(r[HL], n);
+  r.f.z = n == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = 0;
+}
+
+template<unsigned x> void CPU::op_sra_r() {
+  bool c = r[x] & 0x01;
+  r[x] = (int8)r[x] >> 1;
+  r.f.z = r[x] == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+void CPU::op_sra_hl() {
+  uint8 n = op_read(r[HL]);
+  bool c = n & 0x01;
+  n = (int8)n >> 1;
+  op_write(r[HL], n);
+  r.f.z = n == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+template<unsigned x> void CPU::op_srl_r() {
+  bool c = r[x] & 0x01;
+  r[x] >>= 1;
+  r.f.z = r[x] == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+void CPU::op_srl_hl() {
+  uint8 n = op_read(r[HL]);
+  bool c = n & 0x01;
+  n >>= 1;
+  op_write(r[HL], n);
+  r.f.z = n == 0;
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = c;
+}
+
+//single-bit commands
+
+template<unsigned b, unsigned x> void CPU::op_bit_n_r() {
+  r.f.z = (r[x] & (1 << b)) == 0;
+  r.f.n = 0;
+  r.f.h = 1;
+}
+
+template<unsigned b> void CPU::op_bit_n_hl() {
+  uint8 n = op_read(r[HL]);
+  r.f.z = (n & (1 << b)) == 0;
+  r.f.n = 0;
+  r.f.h = 1;
+}
+
+template<unsigned b, unsigned x> void CPU::op_set_n_r() {
+  r[x] |= 1 << b;
+}
+
+template<unsigned b> void CPU::op_set_n_hl() {
+  uint8 n = op_read(r[HL]);
+  n |= 1 << b;
+  op_write(r[HL], n);
+}
+
+template<unsigned b, unsigned x> void CPU::op_res_n_r() {
+  r[x] &= ~(1 << b);
+}
+
+template<unsigned b> void CPU::op_res_n_hl() {
+  uint8 n = op_read(r[HL]);
+  n &= ~(1 << b);
+  op_write(r[HL], n);
+}
+
+//control commands
+
+void CPU::op_ccf() {
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = !r.f.c;
+}
+
+void CPU::op_scf() {
+  r.f.n = 0;
+  r.f.h = 0;
+  r.f.c = 1;
+}
+
+void CPU::op_nop() {
+}
+
+void CPU::op_halt() {
+  status.halt = true;
+  while(status.halt == true) op_io();
+}
+
+void CPU::op_stop() {
+  status.stop = true;
+  while(status.stop == true) op_io();
+}
+
+void CPU::op_di() {
+  status.ime = 0;
+}
+
+void CPU::op_ei() {
+  status.ime = 1;
+}
+
+//jump commands
+
+void CPU::op_jp_nn() {
+  uint8 lo = op_read(r[PC]++);
+  uint8 hi = op_read(r[PC]++);
+  r[PC] = (hi << 8) | (lo << 0);
+  op_io();
+}
+
+void CPU::op_jp_hl() {
+  r[PC] = r[HL];
+}
+
+template<unsigned x, bool y> void CPU::op_jp_f_nn() {
+  uint8 lo = op_read(r[PC]++);
+  uint8 hi = op_read(r[PC]++);
+  if(r.f[x] == y) {
+    r[PC] = (hi << 8) | (lo << 0);
+    op_io();
+  }
+}
+
+void CPU::op_jr_n() {
+  int8 n = op_read(r[PC]++);
+  r[PC] += n;
+  op_io();
+}
+
+template<unsigned x, bool y> void CPU::op_jr_f_n() {
+  int8 n = op_read(r[PC]++);
+  if(r.f[x] == y) {
+    r[PC] += n;
+    op_io();
+  }
+}
+
+void CPU::op_call_nn() {
+  uint8 lo = op_read(r[PC]++);
+  uint8 hi = op_read(r[PC]++);
+  op_write(--r[SP], r[PC] >> 8);
+  op_write(--r[SP], r[PC] >> 0);
+  r[PC] = (hi << 8) | (lo << 0);
+  op_io();
+}
+
+template<unsigned x, bool y> void CPU::op_call_f_nn() {
+  uint8 lo = op_read(r[PC]++);
+  uint8 hi = op_read(r[PC]++);
+  if(r.f[x] == y) {
+    op_write(--r[SP], r[PC] >> 8);
+    op_write(--r[SP], r[PC] >> 0);
+    r[PC] = (hi << 8) | (lo << 0);
+    op_io();
+  }
+}
+
+void CPU::op_ret() {
+  uint8 lo = op_read(r[SP]++);
+  uint8 hi = op_read(r[SP]++);
+  r[PC] = (hi << 8) | (lo << 0);
+  op_io();
+}
+
+template<unsigned x, bool y> void CPU::op_ret_f() {
+  op_io();
+  if(r.f[x] == y) {
+    uint8 lo = op_read(r[SP]++);
+    uint8 hi = op_read(r[SP]++);
+    r[PC] = (hi << 8) | (lo << 0);
+    op_io();
+  }
+}
+
+void CPU::op_reti() {
+  uint8 lo = op_read(r[SP]++);
+  uint8 hi = op_read(r[SP]++);
+  r[PC] = (hi << 8) | (lo << 0);
+  op_io();
+  status.ime = 1;
+}
+
+template<unsigned n> void CPU::op_rst_n() {
+  op_write(--r[SP], r[PC] >> 8);
+  op_write(--r[SP], r[PC] >> 0);
+  r[PC] = n;
+  op_io();
+}
+
+#endif

bsnes/gameboy/cpu/core/core.hpp

@@ -0,0 +1,145 @@
+#include "registers.hpp"
+void (CPU::*opcode_table[256])();
+void (CPU::*opcode_table_cb[256])();
+void initialize_opcode_table();
+
+void op_xx();
+void op_cb();
+
+//8-bit load commands
+template<unsigned x, unsigned y> void op_ld_r_r();
+template<unsigned x> void op_ld_r_n();
+template<unsigned x> void op_ld_r_hl();
+template<unsigned x> void op_ld_hl_r();
+void op_ld_hl_n();
+template<unsigned x> void op_ld_a_rr();
+void op_ld_a_nn();
+template<unsigned x> void op_ld_rr_a();
+void op_ld_nn_a();
+void op_ld_a_ffn();
+void op_ld_ffn_a();
+void op_ld_a_ffc();
+void op_ld_ffc_a();
+void op_ldi_hl_a();
+void op_ldi_a_hl();
+void op_ldd_hl_a();
+void op_ldd_a_hl();
+
+//16-bit load commands
+template<unsigned x> void op_ld_rr_nn();
+void op_ld_nn_sp();
+void op_ld_sp_hl();
+template<unsigned x> void op_push_rr();
+template<unsigned x> void op_pop_rr();
+
+//8-bit arithmetic commands
+void opi_add_a(uint8 x);
+template<unsigned x> void op_add_a_r();
+void op_add_a_n();
+void op_add_a_hl();
+
+void opi_adc_a(uint8 x);
+template<unsigned x> void op_adc_a_r();
+void op_adc_a_n();
+void op_adc_a_hl();
+
+void opi_sub_a(uint8 x);
+template<unsigned x> void op_sub_a_r();
+void op_sub_a_n();
+void op_sub_a_hl();
+
+void opi_sbc_a(uint8 x);
+template<unsigned x> void op_sbc_a_r();
+void op_sbc_a_n();
+void op_sbc_a_hl();
+
+void opi_and_a(uint8 x);
+template<unsigned x> void op_and_a_r();
+void op_and_a_n();
+void op_and_a_hl();
+
+void opi_xor_a(uint8 x);
+template<unsigned x> void op_xor_a_r();
+void op_xor_a_n();
+void op_xor_a_hl();
+
+void opi_or_a(uint8 x);
+template<unsigned x> void op_or_a_r();
+void op_or_a_n();
+void op_or_a_hl();
+
+void opi_cp_a(uint8 x);
+template<unsigned x> void op_cp_a_r();
+void op_cp_a_n();
+void op_cp_a_hl();
+
+template<unsigned x> void op_inc_r();
+void op_inc_hl();
+template<unsigned x> void op_dec_r();
+void op_dec_hl();
+void op_daa();
+void op_cpl();
+
+//16-bit arithmetic commands
+template<unsigned x> void op_add_hl_rr();
+template<unsigned x> void op_inc_rr();
+template<unsigned x> void op_dec_rr();
+void op_add_sp_n();
+void op_ld_hl_sp_n();
+
+//rotate/shift commands
+void op_rlca();
+void op_rla();
+void op_rrca();
+void op_rra();
+template<unsigned x> void op_rlc_r();
+void op_rlc_hl();
+template<unsigned x> void op_rl_r();
+void op_rl_hl();
+template<unsigned x> void op_rrc_r();
+void op_rrc_hl();
+template<unsigned x> void op_rr_r();
+void op_rr_hl();
+template<unsigned x> void op_sla_r();
+void op_sla_hl();
+template<unsigned x> void op_swap_r();
+void op_swap_hl();
+template<unsigned x> void op_sra_r();
+void op_sra_hl();
+template<unsigned x> void op_srl_r();
+void op_srl_hl();
+
+//single-bit commands
+template<unsigned b, unsigned x> void op_bit_n_r();
+template<unsigned b> void op_bit_n_hl();
+template<unsigned b, unsigned x> void op_set_n_r();
+template<unsigned b> void op_set_n_hl();
+template<unsigned b, unsigned x> void op_res_n_r();
+template<unsigned b> void op_res_n_hl();
+
+//control commands
+void op_ccf();
+void op_scf();
+void op_nop();
+void op_halt();
+void op_stop();
+void op_di();
+void op_ei();
+
+//jump commands
+void op_jp_nn();
+void op_jp_hl();
+template<unsigned x, bool y> void op_jp_f_nn();
+void op_jr_n();
+template<unsigned x, bool y> void op_jr_f_n();
+void op_call_nn();
+template<unsigned x, bool y> void op_call_f_nn();
+void op_ret();
+template<unsigned x, bool y> void op_ret_f();
+void op_reti();
+template<unsigned n> void op_rst_n();
+
+//disassembler.cpp
+string disassemble(uint16 pc);
+string disassemble_opcode(uint16 pc);
+string disassemble_opcode_cb(uint16 pc);

bsnes/gameboy/cpu/core/disassembler.cpp

@@ -0,0 +1,560 @@
+#ifdef CPU_CPP
+
+string CPU::disassemble(uint16 pc) {
+  char output[80];
+  memset(output, ' ', sizeof output);
+  output[79] = 0;
+
+  string opcode = disassemble_opcode(pc);
+  string registers = {
+    " AF:", hex<4>(r[AF]),
+    " BC:", hex<4>(r[BC]),
+    " DE:", hex<4>(r[DE]),
+    " HL:", hex<4>(r[HL]),
+    " SP:", hex<4>(r[SP])
+  };
+
+  memcpy(output +   0, hex<4>(pc), 4);
+  memcpy(output +   6, opcode, opcode.length());
+  memcpy(output +  23, registers, registers.length());
+  output[63] = 0;
+  return output;
+}
+
+string CPU::disassemble_opcode(uint16 pc) {
+  uint8 opcode = bus.read(pc);
+  uint8 p0 = bus.read(pc + 1);
+  uint8 p1 = bus.read(pc + 2);
+  uint8 p2 = bus.read(pc + 3);
+
+  switch(opcode) {
+    case 0x00: return { "nop" };
+    case 0x01: return { "ld   bc,$", hex<2>(p1), hex<2>(p0) };
+    case 0x02: return { "ld   (bc),a" };
+    case 0x03: return { "inc  bc" };
+    case 0x04: return { "inc  b" };
+    case 0x05: return { "dec  b" };
+    case 0x06: return { "ld   b,$", hex<2>(p0) };
+    case 0x07: return { "rlc  a" };
+    case 0x08: return { "ld   ($", hex<2>(p1), hex<2>(p0), "),sp" };
+    case 0x09: return { "add  hl,bc" };
+    case 0x0a: return { "ld   a,(bc)" };
+    case 0x0b: return { "dec  bc" };
+    case 0x0c: return { "inc  c" };
+    case 0x0d: return { "dec  c" };
+    case 0x0e: return { "ld   c,$", hex<2>(p0) };
+    case 0x0f: return { "rrc  a" };
+    case 0x10: return { "stop" };
+    case 0x11: return { "ld   de,$", hex<2>(p1), hex<2>(p0) };
+    case 0x12: return { "ld   (de),a" };
+    case 0x13: return { "inc  de" };
+    case 0x14: return { "inc  d" };
+    case 0x15: return { "dec  d" };
+    case 0x16: return { "ld   d,$", hex<2>(p0) };
+    case 0x17: return { "rl   a" };
+    case 0x18: return { "jr   $", hex<4>(r[PC] + 2 + (int8)p0) };
+    case 0x19: return { "add  hl,de" };
+    case 0x1a: return { "ld   a,(de)" };
+    case 0x1b: return { "dec  de" };
+    case 0x1c: return { "inc  e" };
+    case 0x1d: return { "dec  e" };
+    case 0x1e: return { "ld   e,$", hex<2>(p0) };
+    case 0x1f: return { "rr   a" };
+    case 0x20: return { "jr   nz,$", hex<4>(r[PC] + 2 + (int8)p0) };
+    case 0x21: return { "ld   hl,$", hex<2>(p1), hex<2>(p0) };
+    case 0x22: return { "ldi  (hl),a" };
+    case 0x23: return { "inc  hl" };
+    case 0x24: return { "inc  h" };
+    case 0x25: return { "dec  h" };
+    case 0x26: return { "ld   h,$", hex<2>(p0) };
+    case 0x27: return { "daa" };
+    case 0x28: return { "jr   z,$", hex<4>(r[PC] + 2 + (int8)p0) };
+    case 0x29: return { "add  hl,hl" };
+    case 0x2a: return { "ldi  a,(hl)" };
+    case 0x2b: return { "dec  hl" };
+    case 0x2c: return { "inc  l" };
+    case 0x2d: return { "dec  l" };
+    case 0x2e: return { "ld   l,$", hex<2>(p0) };
+    case 0x2f: return { "cpl" };
+    case 0x30: return { "jr   nc,$", hex<4>(r[PC] + 2 + (int8)p0) };
+    case 0x31: return { "ld   sp,$", hex<2>(p1), hex<2>(p0) };
+    case 0x32: return { "ldd  (hl),a" };
+    case 0x33: return { "inc  sp" };
+    case 0x34: return { "inc  (hl)" };
+    case 0x35: return { "dec  (hl)" };
+    case 0x36: return { "ld   (hl),$", hex<2>(p0) };
+    case 0x37: return { "scf" };
+    case 0x38: return { "jr   c,$", hex<4>(r[PC] + 2 + (int8)p0) };
+    case 0x39: return { "add  hl,sp" };
+    case 0x3a: return { "ldd  a,(hl)" };
+    case 0x3b: return { "dec  sp" };
+    case 0x3c: return { "inc  a" };
+    case 0x3d: return { "dec  a" };
+    case 0x3e: return { "ld   a,$", hex<2>(p0) };
+    case 0x3f: return { "ccf" };
+    case 0x40: return { "ld   b,b" };
+    case 0x41: return { "ld   b,c" };
+    case 0x42: return { "ld   b,d" };
+    case 0x43: return { "ld   b,e" };
+    case 0x44: return { "ld   b,h" };
+    case 0x45: return { "ld   b,l" };
+    case 0x46: return { "ld   b,(hl)" };
+    case 0x47: return { "ld   b,a" };
+    case 0x48: return { "ld   c,b" };
+    case 0x49: return { "ld   c,c" };
+    case 0x4a: return { "ld   c,d" };
+    case 0x4b: return { "ld   c,e" };
+    case 0x4c: return { "ld   c,h" };
+    case 0x4d: return { "ld   c,l" };
+    case 0x4e: return { "ld   c,(hl)" };
+    case 0x4f: return { "ld   c,a" };
+    case 0x50: return { "ld   d,b" };
+    case 0x51: return { "ld   d,c" };
+    case 0x52: return { "ld   d,d" };
+    case 0x53: return { "ld   d,e" };
+    case 0x54: return { "ld   d,h" };
+    case 0x55: return { "ld   d,l" };
+    case 0x56: return { "ld   d,(hl)" };
+    case 0x57: return { "ld   d,a" };
+    case 0x58: return { "ld   e,b" };
+    case 0x59: return { "ld   e,c" };
+    case 0x5a: return { "ld   e,d" };
+    case 0x5b: return { "ld   e,e" };
+    case 0x5c: return { "ld   e,h" };
+    case 0x5d: return { "ld   e,l" };
+    case 0x5e: return { "ld   e,(hl)" };
+    case 0x5f: return { "ld   e,a" };
+    case 0x60: return { "ld   h,b" };
+    case 0x61: return { "ld   h,c" };
+    case 0x62: return { "ld   h,d" };
+    case 0x63: return { "ld   h,e" };
+    case 0x64: return { "ld   h,h" };
+    case 0x65: return { "ld   h,l" };
+    case 0x66: return { "ld   h,(hl)" };
+    case 0x67: return { "ld   h,a" };
+    case 0x68: return { "ld   l,b" };
+    case 0x69: return { "ld   l,c" };
+    case 0x6a: return { "ld   l,d" };
+    case 0x6b: return { "ld   l,e" };
+    case 0x6c: return { "ld   l,h" };
+    case 0x6d: return { "ld   l,l" };
+    case 0x6e: return { "ld   l,(hl)" };
+    case 0x6f: return { "ld   l,a" };
+    case 0x70: return { "ld   (hl),b" };
+    case 0x71: return { "ld   (hl),c" };
+    case 0x72: return { "ld   (hl),d" };
+    case 0x73: return { "ld   (hl),e" };
+    case 0x74: return { "ld   (hl),h" };
+    case 0x75: return { "ld   (hl),l" };
+    case 0x76: return { "halt" };
+    case 0x77: return { "ld   (hl),a" };
+    case 0x78: return { "ld   a,b" };
+    case 0x79: return { "ld   a,c" };
+    case 0x7a: return { "ld   a,d" };
+    case 0x7b: return { "ld   a,e" };
+    case 0x7c: return { "ld   a,h" };
+    case 0x7d: return { "ld   a,l" };
+    case 0x7e: return { "ld   a,(hl)" };
+    case 0x7f: return { "ld   a,a" };
+    case 0x80: return { "add  a,b" };
+    case 0x81: return { "add  a,c" };
+    case 0x82: return { "add  a,d" };
+    case 0x83: return { "add  a,e" };
+    case 0x84: return { "add  a,h" };
+    case 0x85: return { "add  a,l" };
+    case 0x86: return { "add  a,(hl)" };
+    case 0x87: return { "add  a,a" };
+    case 0x88: return { "adc  a,b" };
+    case 0x89: return { "adc  a,c" };
+    case 0x8a: return { "adc  a,d" };
+    case 0x8b: return { "adc  a,e" };
+    case 0x8c: return { "adc  a,h" };
+    case 0x8d: return { "adc  a,l" };
+    case 0x8e: return { "adc  a,(hl)" };
+    case 0x8f: return { "adc  a,a" };
+    case 0x90: return { "sub  a,b" };
+    case 0x91: return { "sub  a,c" };
+    case 0x92: return { "sub  a,d" };
+    case 0x93: return { "sub  a,e" };
+    case 0x94: return { "sub  a,h" };
+    case 0x95: return { "sub  a,l" };
+    case 0x96: return { "sub  a,(hl)" };
+    case 0x97: return { "sub  a,a" };
+    case 0x98: return { "sbc  a,b" };
+    case 0x99: return { "sbc  a,c" };
+    case 0x9a: return { "sbc  a,d" };
+    case 0x9b: return { "sbc  a,e" };
+    case 0x9c: return { "sbc  a,h" };
+    case 0x9d: return { "sbc  a,l" };
+    case 0x9e: return { "sbc  a,(hl)" };
+    case 0x9f: return { "sbc  a,a" };
+    case 0xa0: return { "and  a,b" };
+    case 0xa1: return { "and  a,c" };
+    case 0xa2: return { "and  a,d" };
+    case 0xa3: return { "and  a,e" };
+    case 0xa4: return { "and  a,h" };
+    case 0xa5: return { "and  a,l" };
+    case 0xa6: return { "and  a,(hl)" };
+    case 0xa7: return { "and  a,a" };
+    case 0xa8: return { "xor  a,b" };
+    case 0xa9: return { "xor  a,c" };
+    case 0xaa: return { "xor  a,d" };
+    case 0xab: return { "xor  a,e" };
+    case 0xac: return { "xor  a,h" };
+    case 0xad: return { "xor  a,l" };
+    case 0xae: return { "xor  a,(hl)" };
+    case 0xaf: return { "xor  a,a" };
+    case 0xb0: return { "or   a,b" };
+    case 0xb1: return { "or   a,c" };
+    case 0xb2: return { "or   a,d" };
+    case 0xb3: return { "or   a,e" };
+    case 0xb4: return { "or   a,h" };
+    case 0xb5: return { "or   a,l" };
+    case 0xb6: return { "or   a,(hl)" };
+    case 0xb7: return { "or   a,a" };
+    case 0xb8: return { "cp   a,b" };
+    case 0xb9: return { "cp   a,c" };
+    case 0xba: return { "cp   a,d" };
+    case 0xbb: return { "cp   a,e" };
+    case 0xbc: return { "cp   a,h" };
+    case 0xbd: return { "cp   a,l" };
+    case 0xbe: return { "cp   a,(hl)" };
+    case 0xbf: return { "cp   a,a" };
+    case 0xc0: return { "ret  nz" };
+    case 0xc1: return { "pop  bc" };
+    case 0xc2: return { "jp   nz,$", hex<2>(p1), hex<2>(p0) };
+    case 0xc3: return { "jp   $", hex<2>(p1), hex<2>(p0) };
+    case 0xc4: return { "call nz,$", hex<2>(p1), hex<2>(p0) };
+    case 0xc5: return { "push bc" };
+    case 0xc6: return { "add  a,$", hex<2>(p0) };
+    case 0xc7: return { "rst  $0000" };
+    case 0xc8: return { "ret  z" };
+    case 0xc9: return { "ret" };
+    case 0xca: return { "jp   z,$", hex<2>(p1), hex<2>(p0) };
+    case 0xcb: return disassemble_opcode_cb(pc + 1);
+    case 0xcc: return { "call z,$", hex<2>(p1), hex<2>(p0) };
+    case 0xcd: return { "call $", hex<2>(p1), hex<2>(p0) };
+    case 0xce: return { "adc  a,$", hex<2>(p0) };
+    case 0xcf: return { "rst  $0008" };
+    case 0xd0: return { "ret  nc" };
+    case 0xd1: return { "pop  de" };
+    case 0xd2: return { "jp   nc,$", hex<2>(p1), hex<2>(p0) };
+    case 0xd3: return { "xx" };
+    case 0xd4: return { "call nc,$", hex<2>(p1), hex<2>(p0) };
+    case 0xd5: return { "push de" };
+    case 0xd6: return { "sub  a,$", hex<2>(p0) };
+    case 0xd7: return { "rst  $0010" };
+    case 0xd8: return { "ret  c" };
+    case 0xd9: return { "reti" };
+    case 0xda: return { "jp   c,$", hex<2>(p1), hex<2>(p0) };
+    case 0xdb: return { "xx" };
+    case 0xdc: return { "call c,$", hex<2>(p1), hex<2>(p0) };
+    case 0xdd: return { "xx" };
+    case 0xde: return { "sbc  a,$", hex<2>(p0) };
+    case 0xdf: return { "rst  $0018" };
+    case 0xe0: return { "ld   ($ff", hex<2>(p0), "),a" };
+    case 0xe1: return { "pop  hl" };
+    case 0xe2: return { "ld   ($ff00+c),a" };
+    case 0xe3: return { "xx" };
+    case 0xe4: return { "xx" };
+    case 0xe5: return { "push hl" };
+    case 0xe6: return { "and  a,$", hex<2>(p0) };
+    case 0xe7: return { "rst  $0020" };
+    case 0xe8: return { "add  sp,$", hex<4>((int8)p0) };
+    case 0xe9: return { "jp   hl" };
+    case 0xea: return { "ld   ($", hex<2>(p1), hex<2>(p0), "),a" };
+    case 0xeb: return { "xx" };
+    case 0xec: return { "xx" };
+    case 0xed: return { "xx" };
+    case 0xee: return { "xor  a,$", hex<2>(p0) };
+    case 0xef: return { "rst  $0028" };
+    case 0xf0: return { "ld   a,($ff", hex<2>(p0), ")" };
+    case 0xf1: return { "pop  af" };
+    case 0xf2: return { "ld   a,($ff00+c)" };
+    case 0xf3: return { "di" };
+    case 0xf4: return { "xx" };
+    case 0xf5: return { "push af" };
+    case 0xf6: return { "or  a,$", hex<2>(p0) };
+    case 0xf7: return { "rst  $0030" };
+    case 0xf8: return { "ld   hl,sp+$", hex<4>((int8)p0) };
+    case 0xf9: return { "ld   sp,hl" };
+    case 0xfa: return { "ld   a,($", hex<2>(p1), hex<2>(p0), ")" };
+    case 0xfb: return { "ei" };
+    case 0xfc: return { "xx" };
+    case 0xfd: return { "xx" };
+    case 0xfe: return { "cp   a,$", hex<2>(p0) };
+    case 0xff: return { "rst  $0038" };
+  }
+
+  return "";
+}
+
+string CPU::disassemble_opcode_cb(uint16 pc) {
+  uint8 opcode = bus.read(pc);
+  uint8 p0 = bus.read(pc + 1);
+  uint8 p1 = bus.read(pc + 2);
+  uint8 p2 = bus.read(pc + 3);
+
+  switch(opcode) {
+    case 0x00: return { "rlc  b" };
+    case 0x01: return { "rlc  c" };
+    case 0x02: return { "rlc  d" };
+    case 0x03: return { "rlc  e" };
+    case 0x04: return { "rlc  h" };
+    case 0x05: return { "rlc  l" };
+    case 0x06: return { "rlc  (hl)" };
+    case 0x07: return { "rlc  a" };
+    case 0x08: return { "rrc  b" };
+    case 0x09: return { "rrc  c" };
+    case 0x0a: return { "rrc  d" };
+    case 0x0b: return { "rrc  e" };
+    case 0x0c: return { "rrc  h" };
+    case 0x0d: return { "rrc  l" };
+    case 0x0e: return { "rrc  (hl)" };
+    case 0x0f: return { "rrc  a" };
+    case 0x10: return { "rl   b" };
+    case 0x11: return { "rl   c" };
+    case 0x12: return { "rl   d" };
+    case 0x13: return { "rl   e" };
+    case 0x14: return { "rl   h" };
+    case 0x15: return { "rl   l" };
+    case 0x16: return { "rl   (hl)" };
+    case 0x17: return { "rl   a" };
+    case 0x18: return { "rr   b" };
+    case 0x19: return { "rr   c" };
+    case 0x1a: return { "rr   d" };
+    case 0x1b: return { "rr   e" };
+    case 0x1c: return { "rr   h" };
+    case 0x1d: return { "rr   l" };
+    case 0x1e: return { "rr   (hl)" };
+    case 0x1f: return { "rr   a" };
+    case 0x20: return { "sla  b" };
+    case 0x21: return { "sla  c" };
+    case 0x22: return { "sla  d" };
+    case 0x23: return { "sla  e" };
+    case 0x24: return { "sla  h" };
+    case 0x25: return { "sla  l" };
+    case 0x26: return { "sla  (hl)" };
+    case 0x27: return { "sla  a" };
+    case 0x28: return { "sra  b" };
+    case 0x29: return { "sra  c" };
+    case 0x2a: return { "sra  d" };
+    case 0x2b: return { "sra  e" };
+    case 0x2c: return { "sra  h" };
+    case 0x2d: return { "sra  l" };
+    case 0x2e: return { "sra  (hl)" };
+    case 0x2f: return { "sra  a" };
+    case 0x30: return { "swap b" };
+    case 0x31: return { "swap c" };
+    case 0x32: return { "swap d" };
+    case 0x33: return { "swap e" };
+    case 0x34: return { "swap h" };
+    case 0x35: return { "swap l" };
+    case 0x36: return { "swap (hl)" };
+    case 0x37: return { "swap a" };
+    case 0x38: return { "srl  b" };
+    case 0x39: return { "srl  c" };
+    case 0x3a: return { "srl  d" };
+    case 0x3b: return { "srl  e" };
+    case 0x3c: return { "srl  h" };
+    case 0x3d: return { "srl  l" };
+    case 0x3e: return { "srl  (hl)" };
+    case 0x3f: return { "srl  a" };
+    case 0x40: return { "bit  0,b" };
+    case 0x41: return { "bit  0,c" };
+    case 0x42: return { "bit  0,d" };
+    case 0x43: return { "bit  0,e" };
+    case 0x44: return { "bit  0,h" };
+    case 0x45: return { "bit  0,l" };
+    case 0x46: return { "bit  0,(hl)" };
+    case 0x47: return { "bit  0,a" };
+    case 0x48: return { "bit  1,b" };
+    case 0x49: return { "bit  1,c" };
+    case 0x4a: return { "bit  1,d" };
+    case 0x4b: return { "bit  1,e" };
+    case 0x4c: return { "bit  1,h" };
+    case 0x4d: return { "bit  1,l" };
+    case 0x4e: return { "bit  1,(hl)" };
+    case 0x4f: return { "bit  1,a" };
+    case 0x50: return { "bit  2,b" };
+    case 0x51: return { "bit  2,c" };
+    case 0x52: return { "bit  2,d" };
+    case 0x53: return { "bit  2,e" };
+    case 0x54: return { "bit  2,h" };
+    case 0x55: return { "bit  2,l" };
+    case 0x56: return { "bit  2,(hl)" };
+    case 0x57: return { "bit  2,a" };
+    case 0x58: return { "bit  3,b" };
+    case 0x59: return { "bit  3,c" };
+    case 0x5a: return { "bit  3,d" };
+    case 0x5b: return { "bit  3,e" };
+    case 0x5c: return { "bit  3,h" };
+    case 0x5d: return { "bit  3,l" };
+    case 0x5e: return { "bit  3,(hl)" };
+    case 0x5f: return { "bit  3,a" };
+    case 0x60: return { "bit  4,b" };
+    case 0x61: return { "bit  4,c" };
+    case 0x62: return { "bit  4,d" };
+    case 0x63: return { "bit  4,e" };
+    case 0x64: return { "bit  4,h" };
+    case 0x65: return { "bit  4,l" };
+    case 0x66: return { "bit  4,(hl)" };
+    case 0x67: return { "bit  4,a" };
+    case 0x68: return { "bit  5,b" };
+    case 0x69: return { "bit  5,c" };
+    case 0x6a: return { "bit  5,d" };
+    case 0x6b: return { "bit  5,e" };
+    case 0x6c: return { "bit  5,h" };
+    case 0x6d: return { "bit  5,l" };
+    case 0x6e: return { "bit  5,(hl)" };
+    case 0x6f: return { "bit  5,a" };
+    case 0x70: return { "bit  6,b" };
+    case 0x71: return { "bit  6,c" };
+    case 0x72: return { "bit  6,d" };
+    case 0x73: return { "bit  6,e" };
+    case 0x74: return { "bit  6,h" };
+    case 0x75: return { "bit  6,l" };
+    case 0x76: return { "bit  6,(hl)" };
+    case 0x77: return { "bit  6,a" };
+    case 0x78: return { "bit  7,b" };
+    case 0x79: return { "bit  7,c" };
+    case 0x7a: return { "bit  7,d" };
+    case 0x7b: return { "bit  7,e" };
+    case 0x7c: return { "bit  7,h" };
+    case 0x7d: return { "bit  7,l" };
+    case 0x7e: return { "bit  7,(hl)" };
+    case 0x7f: return { "bit  7,a" };
+    case 0x80: return { "res  0,b" };
+    case 0x81: return { "res  0,c" };
+    case 0x82: return { "res  0,d" };
+    case 0x83: return { "res  0,e" };
+    case 0x84: return { "res  0,h" };
+    case 0x85: return { "res  0,l" };
+    case 0x86: return { "res  0,(hl)" };
+    case 0x87: return { "res  0,a" };
+    case 0x88: return { "res  1,b" };
+    case 0x89: return { "res  1,c" };
+    case 0x8a: return { "res  1,d" };
+    case 0x8b: return { "res  1,e" };
+    case 0x8c: return { "res  1,h" };
+    case 0x8d: return { "res  1,l" };
+    case 0x8e: return { "res  1,(hl)" };
+    case 0x8f: return { "res  1,a" };
+    case 0x90: return { "res  2,b" };
+    case 0x91: return { "res  2,c" };
+    case 0x92: return { "res  2,d" };
+    case 0x93: return { "res  2,e" };
+    case 0x94: return { "res  2,h" };
+    case 0x95: return { "res  2,l" };
+    case 0x96: return { "res  2,(hl)" };
+    case 0x97: return { "res  2,a" };
+    case 0x98: return { "res  3,b" };
+    case 0x99: return { "res  3,c" };
+    case 0x9a: return { "res  3,d" };
+    case 0x9b: return { "res  3,e" };
+    case 0x9c: return { "res  3,h" };
+    case 0x9d: return { "res  3,l" };
+    case 0x9e: return { "res  3,(hl)" };
+    case 0x9f: return { "res  3,a" };
+    case 0xa0: return { "res  4,b" };
+    case 0xa1: return { "res  4,c" };
+    case 0xa2: return { "res  4,d" };
+    case 0xa3: return { "res  4,e" };
+    case 0xa4: return { "res  4,h" };
+    case 0xa5: return { "res  4,l" };
+    case 0xa6: return { "res  4,(hl)" };
+    case 0xa7: return { "res  4,a" };
+    case 0xa8: return { "res  5,b" };
+    case 0xa9: return { "res  5,c" };
+    case 0xaa: return { "res  5,d" };
+    case 0xab: return { "res  5,e" };
+    case 0xac: return { "res  5,h" };
+    case 0xad: return { "res  5,l" };
+    case 0xae: return { "res  5,(hl)" };
+    case 0xaf: return { "res  5,a" };
+    case 0xb0: return { "res  6,b" };
+    case 0xb1: return { "res  6,c" };
+    case 0xb2: return { "res  6,d" };
+    case 0xb3: return { "res  6,e" };
+    case 0xb4: return { "res  6,h" };
+    case 0xb5: return { "res  6,l" };
+    case 0xb6: return { "res  6,(hl)" };
+    case 0xb7: return { "res  6,a" };
+    case 0xb8: return { "res  7,b" };
+    case 0xb9: return { "res  7,c" };
+    case 0xba: return { "res  7,d" };
+    case 0xbb: return { "res  7,e" };
+    case 0xbc: return { "res  7,h" };
+    case 0xbd: return { "res  7,l" };
+    case 0xbe: return { "res  7,(hl)" };
+    case 0xbf: return { "res  7,a" };
+    case 0xc0: return { "set  0,b" };
+    case 0xc1: return { "set  0,c" };
+    case 0xc2: return { "set  0,d" };
+    case 0xc3: return { "set  0,e" };
+    case 0xc4: return { "set  0,h" };
+    case 0xc5: return { "set  0,l" };
+    case 0xc6: return { "set  0,(hl)" };
+    case 0xc7: return { "set  0,a" };
+    case 0xc8: return { "set  1,b" };
+    case 0xc9: return { "set  1,c" };
+    case 0xca: return { "set  1,d" };
+    case 0xcb: return { "set  1,e" };
+    case 0xcc: return { "set  1,h" };
+    case 0xcd: return { "set  1,l" };
+    case 0xce: return { "set  1,(hl)" };
+    case 0xcf: return { "set  1,a" };
+    case 0xd0: return { "set  2,b" };
+    case 0xd1: return { "set  2,c" };
+    case 0xd2: return { "set  2,d" };
+    case 0xd3: return { "set  2,e" };
+    case 0xd4: return { "set  2,h" };
+    case 0xd5: return { "set  2,l" };
+    case 0xd6: return { "set  2,(hl)" };
+    case 0xd7: return { "set  2,a" };
+    case 0xd8: return { "set  3,b" };
+    case 0xd9: return { "set  3,c" };
+    case 0xda: return { "set  3,d" };
+    case 0xdb: return { "set  3,e" };
+    case 0xdc: return { "set  3,h" };
+    case 0xdd: return { "set  3,l" };
+    case 0xde: return { "set  3,(hl)" };
+    case 0xdf: return { "set  3,a" };
+    case 0xe0: return { "set  4,b" };
+    case 0xe1: return { "set  4,c" };
+    case 0xe2: return { "set  4,d" };
+    case 0xe3: return { "set  4,e" };
+    case 0xe4: return { "set  4,h" };
+    case 0xe5: return { "set  4,l" };
+    case 0xe6: return { "set  4,(hl)" };
+    case 0xe7: return { "set  4,a" };
+    case 0xe8: return { "set  5,b" };
+    case 0xe9: return { "set  5,c" };
+    case 0xea: return { "set  5,d" };
+    case 0xeb: return { "set  5,e" };
+    case 0xec: return { "set  5,h" };
+    case 0xed: return { "set  5,l" };
+    case 0xee: return { "set  5,(hl)" };
+    case 0xef: return { "set  5,a" };
+    case 0xf0: return { "set  6,b" };
+    case 0xf1: return { "set  6,c" };
+    case 0xf2: return { "set  6,d" };
+    case 0xf3: return { "set  6,e" };
+    case 0xf4: return { "set  6,h" };
+    case 0xf5: return { "set  6,l" };
+    case 0xf6: return { "set  6,(hl)" };
+    case 0xf7: return { "set  6,a" };
+    case 0xf8: return { "set  7,b" };
+    case 0xf9: return { "set  7,c" };
+    case 0xfa: return { "set  7,d" };
+    case 0xfb: return { "set  7,e" };
+    case 0xfc: return { "set  7,h" };
+    case 0xfd: return { "set  7,l" };
+    case 0xfe: return { "set  7,(hl)" };
+    case 0xff: return { "set  7,a" };
+  }
+
+  return "";
+}
+
+#endif

bsnes/gameboy/cpu/core/registers.hpp

@@ -0,0 +1,101 @@
+enum {
+  A, F, AF,
+  B, C, BC,
+  D, E, DE,
+  H, L, HL,
+  SP, PC,
+};
+
+enum {
+  ZF, NF, HF, CF,
+};
+
+//register base class
+//the idea here is to have all registers derive from a single base class.
+//this allows construction of opcodes that can take any register as input or output,
+//despite the fact that behind-the-scenes, special handling is done for eg: F, AF, HL, etc.
+//registers can also be chained together: eg af = 0x0000 writes both a and f.
+struct Register {
+  virtual operator unsigned() const = 0;
+  virtual unsigned operator=(unsigned x) = 0;
+  Register& operator=(const Register &x) { operator=((unsigned)x); return *this; }
+
+  unsigned operator++(int) { unsigned r = *this; operator=(*this + 1); return r; }
+  unsigned operator--(int) { unsigned r = *this; operator=(*this - 1); return r; }
+  unsigned operator++() { return operator=(*this + 1); }
+  unsigned operator--() { return operator=(*this - 1); }
+
+  unsigned operator |=(unsigned x) { return operator=(*this | x); }
+  unsigned operator ^=(unsigned x) { return operator=(*this ^ x); }
+  unsigned operator &=(unsigned x) { return operator=(*this & x); }
+
+  unsigned operator<<=(unsigned x) { return operator=(*this << x); }
+  unsigned operator>>=(unsigned x) { return operator=(*this >> x); }
+
+  unsigned operator +=(unsigned x) { return operator=(*this + x); }
+  unsigned operator -=(unsigned x) { return operator=(*this - x); }
+  unsigned operator *=(unsigned x) { return operator=(*this * x); }
+  unsigned operator /=(unsigned x) { return operator=(*this / x); }
+  unsigned operator %=(unsigned x) { return operator=(*this % x); }
+};
+
+struct Register8 : Register {
+  uint8 data;
+  operator unsigned() const { return data; }
+  unsigned operator=(unsigned x) { return data = x; }
+};
+
+struct RegisterF : Register {
+  bool z, n, h, c;
+  operator unsigned() const { return (z << 7) | (n << 6) | (h << 5) | (c << 4); }
+  unsigned operator=(unsigned x) { z = x & 0x80; n = x & 0x40; h = x & 0x20; c = x & 0x10; return *this; }
+  bool& operator[](unsigned r) {
+    static bool* table[] = { &z, &n, &h, &c };
+    return *table[r];
+  }
+};
+
+struct Register16 : Register {
+  uint16 data;
+  operator unsigned() const { return data; }
+  unsigned operator=(unsigned x) { return data = x; }
+};
+
+struct RegisterAF : Register {
+  Register8 &hi;
+  RegisterF &lo;
+  operator unsigned() const { return (hi << 8) | (lo << 0); }
+  unsigned operator=(unsigned x) { hi = x >> 8; lo = x >> 0; return *this; }
+  RegisterAF(Register8 &hi, RegisterF &lo) : hi(hi), lo(lo) {}
+};
+
+struct RegisterW : Register {
+  Register8 &hi, &lo;
+  operator unsigned() const { return (hi << 8) | (lo << 0); }
+  unsigned operator=(unsigned x) { hi = x >> 8; lo = x >> 0; return *this; }
+  RegisterW(Register8 &hi, Register8 &lo) : hi(hi), lo(lo) {}
+};
+
+struct Registers {
+  Register8  a;
+  RegisterF  f;
+  RegisterAF af;
+  Register8  b;
+  Register8  c;
+  RegisterW  bc;
+  Register8  d;
+  Register8  e;
+  RegisterW  de;
+  Register8  h;
+  Register8  l;
+  RegisterW  hl;
+  Register16 sp;
+  Register16 pc;
+
+  Register& operator[](unsigned r) {
+    static Register* table[] = { &a, &f, &af, &b, &c, &bc, &d, &e, &de, &h, &l, &hl, &sp, &pc };
+    return *table[r];
+  }
+
+  Registers() : af(a, f), bc(b, c), de(d, e), hl(h, l) {}
+} r;

bsnes/gameboy/cpu/core/table.cpp

@@ -0,0 +1,519 @@
+#ifdef CPU_CPP
+
+void CPU::initialize_opcode_table() {
+  opcode_table[0x00] = &CPU::op_nop;
+  opcode_table[0x01] = &CPU::op_ld_rr_nn<BC>;
+  opcode_table[0x02] = &CPU::op_ld_rr_a<BC>;
+  opcode_table[0x03] = &CPU::op_inc_rr<BC>;
+  opcode_table[0x04] = &CPU::op_inc_r<B>;
+  opcode_table[0x05] = &CPU::op_dec_r<B>;
+  opcode_table[0x06] = &CPU::op_ld_r_n<B>;
+  opcode_table[0x07] = &CPU::op_rlca;
+  opcode_table[0x08] = &CPU::op_ld_nn_sp;
+  opcode_table[0x09] = &CPU::op_add_hl_rr<BC>;
+  opcode_table[0x0a] = &CPU::op_ld_a_rr<BC>;
+  opcode_table[0x0b] = &CPU::op_dec_rr<BC>;
+  opcode_table[0x0c] = &CPU::op_inc_r<C>;
+  opcode_table[0x0d] = &CPU::op_dec_r<C>;
+  opcode_table[0x0e] = &CPU::op_ld_r_n<C>;
+  opcode_table[0x0f] = &CPU::op_rrca;
+  opcode_table[0x10] = &CPU::op_stop;
+  opcode_table[0x11] = &CPU::op_ld_rr_nn<DE>;
+  opcode_table[0x12] = &CPU::op_ld_rr_a<DE>;
+  opcode_table[0x13] = &CPU::op_inc_rr<DE>;
+  opcode_table[0x14] = &CPU::op_inc_r<D>;
+  opcode_table[0x15] = &CPU::op_dec_r<D>;
+  opcode_table[0x16] = &CPU::op_ld_r_n<D>;
+  opcode_table[0x17] = &CPU::op_rla;
+  opcode_table[0x18] = &CPU::op_jr_n;
+  opcode_table[0x19] = &CPU::op_add_hl_rr<DE>;
+  opcode_table[0x1a] = &CPU::op_ld_a_rr<DE>;
+  opcode_table[0x1b] = &CPU::op_dec_rr<DE>;
+  opcode_table[0x1c] = &CPU::op_inc_r<E>;
+  opcode_table[0x1d] = &CPU::op_dec_r<E>;
+  opcode_table[0x1e] = &CPU::op_ld_r_n<E>;
+  opcode_table[0x1f] = &CPU::op_rra;
+  opcode_table[0x20] = &CPU::op_jr_f_n<ZF, 0>;
+  opcode_table[0x21] = &CPU::op_ld_rr_nn<HL>;
+  opcode_table[0x22] = &CPU::op_ldi_hl_a;
+  opcode_table[0x23] = &CPU::op_inc_rr<HL>;
+  opcode_table[0x24] = &CPU::op_inc_r<H>;
+  opcode_table[0x25] = &CPU::op_dec_r<H>;
+  opcode_table[0x26] = &CPU::op_ld_r_n<H>;
+  opcode_table[0x27] = &CPU::op_daa;
+  opcode_table[0x28] = &CPU::op_jr_f_n<ZF, 1>;
+  opcode_table[0x29] = &CPU::op_add_hl_rr<HL>;
+  opcode_table[0x2a] = &CPU::op_ldi_a_hl;
+  opcode_table[0x2b] = &CPU::op_dec_rr<HL>;
+  opcode_table[0x2c] = &CPU::op_inc_r<L>;
+  opcode_table[0x2d] = &CPU::op_dec_r<L>;
+  opcode_table[0x2e] = &CPU::op_ld_r_n<L>;
+  opcode_table[0x2f] = &CPU::op_cpl;
+  opcode_table[0x30] = &CPU::op_jr_f_n<CF, 0>;
+  opcode_table[0x31] = &CPU::op_ld_rr_nn<SP>;
+  opcode_table[0x32] = &CPU::op_ldd_hl_a;
+  opcode_table[0x33] = &CPU::op_inc_rr<SP>;
+  opcode_table[0x34] = &CPU::op_inc_hl;
+  opcode_table[0x35] = &CPU::op_dec_hl;
+  opcode_table[0x36] = &CPU::op_ld_hl_n;
+  opcode_table[0x37] = &CPU::op_scf;
+  opcode_table[0x38] = &CPU::op_jr_f_n<CF, 1>;
+  opcode_table[0x39] = &CPU::op_add_hl_rr<SP>;
+  opcode_table[0x3a] = &CPU::op_ldd_a_hl;
+  opcode_table[0x3b] = &CPU::op_dec_rr<SP>;
+  opcode_table[0x3c] = &CPU::op_inc_r<A>;
+  opcode_table[0x3d] = &CPU::op_dec_r<A>;
+  opcode_table[0x3e] = &CPU::op_ld_r_n<A>;
+  opcode_table[0x3f] = &CPU::op_ccf;
+  opcode_table[0x40] = &CPU::op_ld_r_r<B, B>;
+  opcode_table[0x41] = &CPU::op_ld_r_r<B, C>;
+  opcode_table[0x42] = &CPU::op_ld_r_r<B, D>;
+  opcode_table[0x43] = &CPU::op_ld_r_r<B, E>;
+  opcode_table[0x44] = &CPU::op_ld_r_r<B, H>;
+  opcode_table[0x45] = &CPU::op_ld_r_r<B, L>;
+  opcode_table[0x46] = &CPU::op_ld_r_hl<B>;
+  opcode_table[0x47] = &CPU::op_ld_r_r<B, A>;
+  opcode_table[0x48] = &CPU::op_ld_r_r<C, B>;
+  opcode_table[0x49] = &CPU::op_ld_r_r<C, C>;
+  opcode_table[0x4a] = &CPU::op_ld_r_r<C, D>;
+  opcode_table[0x4b] = &CPU::op_ld_r_r<C, E>;
+  opcode_table[0x4c] = &CPU::op_ld_r_r<C, H>;
+  opcode_table[0x4d] = &CPU::op_ld_r_r<C, L>;
+  opcode_table[0x4e] = &CPU::op_ld_r_hl<C>;
+  opcode_table[0x4f] = &CPU::op_ld_r_r<C, A>;
+  opcode_table[0x50] = &CPU::op_ld_r_r<D, B>;
+  opcode_table[0x51] = &CPU::op_ld_r_r<D, C>;
+  opcode_table[0x52] = &CPU::op_ld_r_r<D, D>;
+  opcode_table[0x53] = &CPU::op_ld_r_r<D, E>;
+  opcode_table[0x54] = &CPU::op_ld_r_r<D, H>;
+  opcode_table[0x55] = &CPU::op_ld_r_r<D, L>;
+  opcode_table[0x56] = &CPU::op_ld_r_hl<D>;
+  opcode_table[0x57] = &CPU::op_ld_r_r<D, A>;
+  opcode_table[0x58] = &CPU::op_ld_r_r<E, B>;
+  opcode_table[0x59] = &CPU::op_ld_r_r<E, C>;
+  opcode_table[0x5a] = &CPU::op_ld_r_r<E, D>;
+  opcode_table[0x5b] = &CPU::op_ld_r_r<E, E>;
+  opcode_table[0x5c] = &CPU::op_ld_r_r<E, H>;
+  opcode_table[0x5d] = &CPU::op_ld_r_r<E, L>;
+  opcode_table[0x5e] = &CPU::op_ld_r_hl<E>;
+  opcode_table[0x5f] = &CPU::op_ld_r_r<E, A>;
+  opcode_table[0x60] = &CPU::op_ld_r_r<H, B>;
+  opcode_table[0x61] = &CPU::op_ld_r_r<H, C>;
+  opcode_table[0x62] = &CPU::op_ld_r_r<H, D>;
+  opcode_table[0x63] = &CPU::op_ld_r_r<H, E>;
+  opcode_table[0x64] = &CPU::op_ld_r_r<H, H>;
+  opcode_table[0x65] = &CPU::op_ld_r_r<H, L>;
+  opcode_table[0x66] = &CPU::op_ld_r_hl<H>;
+  opcode_table[0x67] = &CPU::op_ld_r_r<H, A>;
+  opcode_table[0x68] = &CPU::op_ld_r_r<L, B>;
+  opcode_table[0x69] = &CPU::op_ld_r_r<L, C>;
+  opcode_table[0x6a] = &CPU::op_ld_r_r<L, D>;
+  opcode_table[0x6b] = &CPU::op_ld_r_r<L, E>;
+  opcode_table[0x6c] = &CPU::op_ld_r_r<L, H>;
+  opcode_table[0x6d] = &CPU::op_ld_r_r<L, L>;
+  opcode_table[0x6e] = &CPU::op_ld_r_hl<L>;
+  opcode_table[0x6f] = &CPU::op_ld_r_r<L, A>;
+  opcode_table[0x70] = &CPU::op_ld_hl_r<B>;
+  opcode_table[0x71] = &CPU::op_ld_hl_r<C>;
+  opcode_table[0x72] = &CPU::op_ld_hl_r<D>;
+  opcode_table[0x73] = &CPU::op_ld_hl_r<E>;
+  opcode_table[0x74] = &CPU::op_ld_hl_r<H>;
+  opcode_table[0x75] = &CPU::op_ld_hl_r<L>;
+  opcode_table[0x76] = &CPU::op_halt;
+  opcode_table[0x77] = &CPU::op_ld_hl_r<A>;
+  opcode_table[0x78] = &CPU::op_ld_r_r<A, B>;
+  opcode_table[0x79] = &CPU::op_ld_r_r<A, C>;
+  opcode_table[0x7a] = &CPU::op_ld_r_r<A, D>;
+  opcode_table[0x7b] = &CPU::op_ld_r_r<A, E>;
+  opcode_table[0x7c] = &CPU::op_ld_r_r<A, H>;
+  opcode_table[0x7d] = &CPU::op_ld_r_r<A, L>;
+  opcode_table[0x7e] = &CPU::op_ld_r_hl<A>;
+  opcode_table[0x7f] = &CPU::op_ld_r_r<A, A>;
+  opcode_table[0x80] = &CPU::op_add_a_r<B>;
+  opcode_table[0x81] = &CPU::op_add_a_r<C>;
+  opcode_table[0x82] = &CPU::op_add_a_r<D>;
+  opcode_table[0x83] = &CPU::op_add_a_r<E>;
+  opcode_table[0x84] = &CPU::op_add_a_r<H>;
+  opcode_table[0x85] = &CPU::op_add_a_r<L>;
+  opcode_table[0x86] = &CPU::op_add_a_hl;
+  opcode_table[0x87] = &CPU::op_add_a_r<A>;
+  opcode_table[0x88] = &CPU::op_adc_a_r<B>;
+  opcode_table[0x89] = &CPU::op_adc_a_r<C>;
+  opcode_table[0x8a] = &CPU::op_adc_a_r<D>;
+  opcode_table[0x8b] = &CPU::op_adc_a_r<E>;
+  opcode_table[0x8c] = &CPU::op_adc_a_r<H>;
+  opcode_table[0x8d] = &CPU::op_adc_a_r<L>;
+  opcode_table[0x8e] = &CPU::op_adc_a_hl;
+  opcode_table[0x8f] = &CPU::op_adc_a_r<A>;
+  opcode_table[0x90] = &CPU::op_sub_a_r<B>;
+  opcode_table[0x91] = &CPU::op_sub_a_r<C>;
+  opcode_table[0x92] = &CPU::op_sub_a_r<D>;
+  opcode_table[0x93] = &CPU::op_sub_a_r<E>;
+  opcode_table[0x94] = &CPU::op_sub_a_r<H>;
+  opcode_table[0x95] = &CPU::op_sub_a_r<L>;
+  opcode_table[0x96] = &CPU::op_sub_a_hl;
+  opcode_table[0x97] = &CPU::op_sub_a_r<A>;
+  opcode_table[0x98] = &CPU::op_sbc_a_r<B>;
+  opcode_table[0x99] = &CPU::op_sbc_a_r<C>;
+  opcode_table[0x9a] = &CPU::op_sbc_a_r<D>;
+  opcode_table[0x9b] = &CPU::op_sbc_a_r<E>;
+  opcode_table[0x9c] = &CPU::op_sbc_a_r<H>;
+  opcode_table[0x9d] = &CPU::op_sbc_a_r<L>;
+  opcode_table[0x9e] = &CPU::op_sbc_a_hl;
+  opcode_table[0x9f] = &CPU::op_sbc_a_r<A>;
+  opcode_table[0xa0] = &CPU::op_and_a_r<B>;
+  opcode_table[0xa1] = &CPU::op_and_a_r<C>;
+  opcode_table[0xa2] = &CPU::op_and_a_r<D>;
+  opcode_table[0xa3] = &CPU::op_and_a_r<E>;
+  opcode_table[0xa4] = &CPU::op_and_a_r<H>;
+  opcode_table[0xa5] = &CPU::op_and_a_r<L>;
+  opcode_table[0xa6] = &CPU::op_and_a_hl;
+  opcode_table[0xa7] = &CPU::op_and_a_r<A>;
+  opcode_table[0xa8] = &CPU::op_xor_a_r<B>;
+  opcode_table[0xa9] = &CPU::op_xor_a_r<C>;
+  opcode_table[0xaa] = &CPU::op_xor_a_r<D>;
+  opcode_table[0xab] = &CPU::op_xor_a_r<E>;
+  opcode_table[0xac] = &CPU::op_xor_a_r<H>;
+  opcode_table[0xad] = &CPU::op_xor_a_r<L>;
+  opcode_table[0xae] = &CPU::op_xor_a_hl;
+  opcode_table[0xaf] = &CPU::op_xor_a_r<A>;
+  opcode_table[0xb0] = &CPU::op_or_a_r<B>;
+  opcode_table[0xb1] = &CPU::op_or_a_r<C>;
+  opcode_table[0xb2] = &CPU::op_or_a_r<D>;
+  opcode_table[0xb3] = &CPU::op_or_a_r<E>;
+  opcode_table[0xb4] = &CPU::op_or_a_r<H>;
+  opcode_table[0xb5] = &CPU::op_or_a_r<L>;
+  opcode_table[0xb6] = &CPU::op_or_a_hl;
+  opcode_table[0xb7] = &CPU::op_or_a_r<A>;
+  opcode_table[0xb8] = &CPU::op_cp_a_r<B>;
+  opcode_table[0xb9] = &CPU::op_cp_a_r<C>;
+  opcode_table[0xba] = &CPU::op_cp_a_r<D>;
+  opcode_table[0xbb] = &CPU::op_cp_a_r<E>;
+  opcode_table[0xbc] = &CPU::op_cp_a_r<H>;
+  opcode_table[0xbd] = &CPU::op_cp_a_r<L>;
+  opcode_table[0xbe] = &CPU::op_cp_a_hl;
+  opcode_table[0xbf] = &CPU::op_cp_a_r<A>;
+  opcode_table[0xc0] = &CPU::op_ret_f<ZF, 0>;
+  opcode_table[0xc1] = &CPU::op_pop_rr<BC>;
+  opcode_table[0xc2] = &CPU::op_jp_f_nn<ZF, 0>;
+  opcode_table[0xc3] = &CPU::op_jp_nn;
+  opcode_table[0xc4] = &CPU::op_call_f_nn<ZF, 0>;
+  opcode_table[0xc5] = &CPU::op_push_rr<BC>;
+  opcode_table[0xc6] = &CPU::op_add_a_n;
+  opcode_table[0xc7] = &CPU::op_rst_n<0x00>;
+  opcode_table[0xc8] = &CPU::op_ret_f<ZF, 1>;
+  opcode_table[0xc9] = &CPU::op_ret;
+  opcode_table[0xca] = &CPU::op_jp_f_nn<ZF, 1>;
+  opcode_table[0xcb] = &CPU::op_cb;
+  opcode_table[0xcc] = &CPU::op_call_f_nn<ZF, 1>;
+  opcode_table[0xcd] = &CPU::op_call_nn;
+  opcode_table[0xce] = &CPU::op_adc_a_n;
+  opcode_table[0xcf] = &CPU::op_rst_n<0x08>;
+  opcode_table[0xd0] = &CPU::op_ret_f<CF, 0>;
+  opcode_table[0xd1] = &CPU::op_pop_rr<DE>;
+  opcode_table[0xd2] = &CPU::op_jp_f_nn<CF, 0>;
+  opcode_table[0xd3] = &CPU::op_xx;
+  opcode_table[0xd4] = &CPU::op_call_f_nn<CF, 0>;
+  opcode_table[0xd5] = &CPU::op_push_rr<DE>;
+  opcode_table[0xd6] = &CPU::op_sub_a_n;
+  opcode_table[0xd7] = &CPU::op_rst_n<0x10>;
+  opcode_table[0xd8] = &CPU::op_ret_f<CF, 1>;
+  opcode_table[0xd9] = &CPU::op_reti;
+  opcode_table[0xda] = &CPU::op_jp_f_nn<CF, 1>;
+  opcode_table[0xdb] = &CPU::op_xx;
+  opcode_table[0xdc] = &CPU::op_call_f_nn<CF, 1>;
+  opcode_table[0xdd] = &CPU::op_xx;
+  opcode_table[0xde] = &CPU::op_sbc_a_n;
+  opcode_table[0xdf] = &CPU::op_rst_n<0x18>;
+  opcode_table[0xe0] = &CPU::op_ld_ffn_a;
+  opcode_table[0xe1] = &CPU::op_pop_rr<HL>;
+  opcode_table[0xe2] = &CPU::op_ld_ffc_a;
+  opcode_table[0xe3] = &CPU::op_xx;
+  opcode_table[0xe4] = &CPU::op_xx;
+  opcode_table[0xe5] = &CPU::op_push_rr<HL>;
+  opcode_table[0xe6] = &CPU::op_and_a_n;
+  opcode_table[0xe7] = &CPU::op_rst_n<0x20>;
+  opcode_table[0xe8] = &CPU::op_add_sp_n;
+  opcode_table[0xe9] = &CPU::op_jp_hl;
+  opcode_table[0xea] = &CPU::op_ld_nn_a;
+  opcode_table[0xeb] = &CPU::op_xx;
+  opcode_table[0xec] = &CPU::op_xx;
+  opcode_table[0xed] = &CPU::op_xx;
+  opcode_table[0xee] = &CPU::op_xor_a_n;
+  opcode_table[0xef] = &CPU::op_rst_n<0x28>;
+  opcode_table[0xf0] = &CPU::op_ld_a_ffn;
+  opcode_table[0xf1] = &CPU::op_pop_rr<AF>;
+  opcode_table[0xf2] = &CPU::op_ld_a_ffc;
+  opcode_table[0xf3] = &CPU::op_di;
+  opcode_table[0xf4] = &CPU::op_xx;
+  opcode_table[0xf5] = &CPU::op_push_rr<AF>;
+  opcode_table[0xf6] = &CPU::op_or_a_n;
+  opcode_table[0xf7] = &CPU::op_rst_n<0x30>;
+  opcode_table[0xf8] = &CPU::op_ld_hl_sp_n;
+  opcode_table[0xf9] = &CPU::op_ld_sp_hl;
+  opcode_table[0xfa] = &CPU::op_ld_a_nn;
+  opcode_table[0xfb] = &CPU::op_ei;
+  opcode_table[0xfc] = &CPU::op_xx;
+  opcode_table[0xfd] = &CPU::op_xx;
+  opcode_table[0xfe] = &CPU::op_cp_a_n;
+  opcode_table[0xff] = &CPU::op_rst_n<0x38>;
+
+  opcode_table_cb[0x00] = &CPU::op_rlc_r<B>;
+  opcode_table_cb[0x01] = &CPU::op_rlc_r<C>;
+  opcode_table_cb[0x02] = &CPU::op_rlc_r<D>;
+  opcode_table_cb[0x03] = &CPU::op_rlc_r<E>;
+  opcode_table_cb[0x04] = &CPU::op_rlc_r<H>;
+  opcode_table_cb[0x05] = &CPU::op_rlc_r<L>;
+  opcode_table_cb[0x06] = &CPU::op_rlc_hl;
+  opcode_table_cb[0x07] = &CPU::op_rlc_r<A>;
+  opcode_table_cb[0x08] = &CPU::op_rrc_r<B>;
+  opcode_table_cb[0x09] = &CPU::op_rrc_r<C>;
+  opcode_table_cb[0x0a] = &CPU::op_rrc_r<D>;
+  opcode_table_cb[0x0b] = &CPU::op_rrc_r<E>;
+  opcode_table_cb[0x0c] = &CPU::op_rrc_r<H>;
+  opcode_table_cb[0x0d] = &CPU::op_rrc_r<L>;
+  opcode_table_cb[0x0e] = &CPU::op_rrc_hl;
+  opcode_table_cb[0x0f] = &CPU::op_rrc_r<A>;
+  opcode_table_cb[0x10] = &CPU::op_rl_r<B>;
+  opcode_table_cb[0x11] = &CPU::op_rl_r<C>;
+  opcode_table_cb[0x12] = &CPU::op_rl_r<D>;
+  opcode_table_cb[0x13] = &CPU::op_rl_r<E>;
+  opcode_table_cb[0x14] = &CPU::op_rl_r<H>;
+  opcode_table_cb[0x15] = &CPU::op_rl_r<L>;
+  opcode_table_cb[0x16] = &CPU::op_rl_hl;
+  opcode_table_cb[0x17] = &CPU::op_rl_r<A>;
+  opcode_table_cb[0x18] = &CPU::op_rr_r<B>;
+  opcode_table_cb[0x19] = &CPU::op_rr_r<C>;
+  opcode_table_cb[0x1a] = &CPU::op_rr_r<D>;
+  opcode_table_cb[0x1b] = &CPU::op_rr_r<E>;
+  opcode_table_cb[0x1c] = &CPU::op_rr_r<H>;
+  opcode_table_cb[0x1d] = &CPU::op_rr_r<L>;
+  opcode_table_cb[0x1e] = &CPU::op_rr_hl;
+  opcode_table_cb[0x1f] = &CPU::op_rr_r<A>;
+  opcode_table_cb[0x20] = &CPU::op_sla_r<B>;
+  opcode_table_cb[0x21] = &CPU::op_sla_r<C>;
+  opcode_table_cb[0x22] = &CPU::op_sla_r<D>;
+  opcode_table_cb[0x23] = &CPU::op_sla_r<E>;
+  opcode_table_cb[0x24] = &CPU::op_sla_r<H>;
+  opcode_table_cb[0x25] = &CPU::op_sla_r<L>;
+  opcode_table_cb[0x26] = &CPU::op_sla_hl;
+  opcode_table_cb[0x27] = &CPU::op_sla_r<A>;
+  opcode_table_cb[0x28] = &CPU::op_sra_r<B>;
+  opcode_table_cb[0x29] = &CPU::op_sra_r<C>;
+  opcode_table_cb[0x2a] = &CPU::op_sra_r<D>;
+  opcode_table_cb[0x2b] = &CPU::op_sra_r<E>;
+  opcode_table_cb[0x2c] = &CPU::op_sra_r<H>;
+  opcode_table_cb[0x2d] = &CPU::op_sra_r<L>;
+  opcode_table_cb[0x2e] = &CPU::op_sra_hl;
+  opcode_table_cb[0x2f] = &CPU::op_sra_r<A>;
+  opcode_table_cb[0x30] = &CPU::op_swap_r<B>;
+  opcode_table_cb[0x31] = &CPU::op_swap_r<C>;
+  opcode_table_cb[0x32] = &CPU::op_swap_r<D>;
+  opcode_table_cb[0x33] = &CPU::op_swap_r<E>;
+  opcode_table_cb[0x34] = &CPU::op_swap_r<H>;
+  opcode_table_cb[0x35] = &CPU::op_swap_r<L>;
+  opcode_table_cb[0x36] = &CPU::op_swap_hl;
+  opcode_table_cb[0x37] = &CPU::op_swap_r<A>;
+  opcode_table_cb[0x38] = &CPU::op_srl_r<B>;
+  opcode_table_cb[0x39] = &CPU::op_srl_r<C>;
+  opcode_table_cb[0x3a] = &CPU::op_srl_r<D>;
+  opcode_table_cb[0x3b] = &CPU::op_srl_r<E>;
+  opcode_table_cb[0x3c] = &CPU::op_srl_r<H>;
+  opcode_table_cb[0x3d] = &CPU::op_srl_r<L>;
+  opcode_table_cb[0x3e] = &CPU::op_srl_hl;
+  opcode_table_cb[0x3f] = &CPU::op_srl_r<A>;
+  opcode_table_cb[0x40] = &CPU::op_bit_n_r<0, B>;
+  opcode_table_cb[0x41] = &CPU::op_bit_n_r<0, C>;
+  opcode_table_cb[0x42] = &CPU::op_bit_n_r<0, D>;
+  opcode_table_cb[0x43] = &CPU::op_bit_n_r<0, E>;
+  opcode_table_cb[0x44] = &CPU::op_bit_n_r<0, H>;
+  opcode_table_cb[0x45] = &CPU::op_bit_n_r<0, L>;
+  opcode_table_cb[0x46] = &CPU::op_bit_n_hl<0>;
+  opcode_table_cb[0x47] = &CPU::op_bit_n_r<0, A>;
+  opcode_table_cb[0x48] = &CPU::op_bit_n_r<1, B>;
+  opcode_table_cb[0x49] = &CPU::op_bit_n_r<1, C>;
+  opcode_table_cb[0x4a] = &CPU::op_bit_n_r<1, D>;
+  opcode_table_cb[0x4b] = &CPU::op_bit_n_r<1, E>;
+  opcode_table_cb[0x4c] = &CPU::op_bit_n_r<1, H>;
+  opcode_table_cb[0x4d] = &CPU::op_bit_n_r<1, L>;
+  opcode_table_cb[0x4e] = &CPU::op_bit_n_hl<1>;
+  opcode_table_cb[0x4f] = &CPU::op_bit_n_r<1, A>;
+  opcode_table_cb[0x50] = &CPU::op_bit_n_r<2, B>;
+  opcode_table_cb[0x51] = &CPU::op_bit_n_r<2, C>;
+  opcode_table_cb[0x52] = &CPU::op_bit_n_r<2, D>;
+  opcode_table_cb[0x53] = &CPU::op_bit_n_r<2, E>;
+  opcode_table_cb[0x54] = &CPU::op_bit_n_r<2, H>;
+  opcode_table_cb[0x55] = &CPU::op_bit_n_r<2, L>;
+  opcode_table_cb[0x56] = &CPU::op_bit_n_hl<2>;
+  opcode_table_cb[0x57] = &CPU::op_bit_n_r<2, A>;
+  opcode_table_cb[0x58] = &CPU::op_bit_n_r<3, B>;
+  opcode_table_cb[0x59] = &CPU::op_bit_n_r<3, C>;
+  opcode_table_cb[0x5a] = &CPU::op_bit_n_r<3, D>;
+  opcode_table_cb[0x5b] = &CPU::op_bit_n_r<3, E>;
+  opcode_table_cb[0x5c] = &CPU::op_bit_n_r<3, H>;
+  opcode_table_cb[0x5d] = &CPU::op_bit_n_r<3, L>;
+  opcode_table_cb[0x5e] = &CPU::op_bit_n_hl<3>;
+  opcode_table_cb[0x5f] = &CPU::op_bit_n_r<3, A>;
+  opcode_table_cb[0x60] = &CPU::op_bit_n_r<4, B>;
+  opcode_table_cb[0x61] = &CPU::op_bit_n_r<4, C>;
+  opcode_table_cb[0x62] = &CPU::op_bit_n_r<4, D>;
+  opcode_table_cb[0x63] = &CPU::op_bit_n_r<4, E>;
+  opcode_table_cb[0x64] = &CPU::op_bit_n_r<4, H>;
+  opcode_table_cb[0x65] = &CPU::op_bit_n_r<4, L>;
+  opcode_table_cb[0x66] = &CPU::op_bit_n_hl<4>;
+  opcode_table_cb[0x67] = &CPU::op_bit_n_r<4, A>;
+  opcode_table_cb[0x68] = &CPU::op_bit_n_r<5, B>;
+  opcode_table_cb[0x69] = &CPU::op_bit_n_r<5, C>;
+  opcode_table_cb[0x6a] = &CPU::op_bit_n_r<5, D>;
+  opcode_table_cb[0x6b] = &CPU::op_bit_n_r<5, E>;
+  opcode_table_cb[0x6c] = &CPU::op_bit_n_r<5, H>;
+  opcode_table_cb[0x6d] = &CPU::op_bit_n_r<5, L>;
+  opcode_table_cb[0x6e] = &CPU::op_bit_n_hl<5>;
+  opcode_table_cb[0x6f] = &CPU::op_bit_n_r<5, A>;
+  opcode_table_cb[0x70] = &CPU::op_bit_n_r<6, B>;
+  opcode_table_cb[0x71] = &CPU::op_bit_n_r<6, C>;
+  opcode_table_cb[0x72] = &CPU::op_bit_n_r<6, D>;
+  opcode_table_cb[0x73] = &CPU::op_bit_n_r<6, E>;
+  opcode_table_cb[0x74] = &CPU::op_bit_n_r<6, H>;
+  opcode_table_cb[0x75] = &CPU::op_bit_n_r<6, L>;
+  opcode_table_cb[0x76] = &CPU::op_bit_n_hl<6>;
+  opcode_table_cb[0x77] = &CPU::op_bit_n_r<6, A>;
+  opcode_table_cb[0x78] = &CPU::op_bit_n_r<7, B>;
+  opcode_table_cb[0x79] = &CPU::op_bit_n_r<7, C>;
+  opcode_table_cb[0x7a] = &CPU::op_bit_n_r<7, D>;
+  opcode_table_cb[0x7b] = &CPU::op_bit_n_r<7, E>;
+  opcode_table_cb[0x7c] = &CPU::op_bit_n_r<7, H>;
+  opcode_table_cb[0x7d] = &CPU::op_bit_n_r<7, L>;
+  opcode_table_cb[0x7e] = &CPU::op_bit_n_hl<7>;
+  opcode_table_cb[0x7f] = &CPU::op_bit_n_r<7, A>;
+  opcode_table_cb[0x80] = &CPU::op_res_n_r<0, B>;
+  opcode_table_cb[0x81] = &CPU::op_res_n_r<0, C>;
+  opcode_table_cb[0x82] = &CPU::op_res_n_r<0, D>;
+  opcode_table_cb[0x83] = &CPU::op_res_n_r<0, E>;
+  opcode_table_cb[0x84] = &CPU::op_res_n_r<0, H>;
+  opcode_table_cb[0x85] = &CPU::op_res_n_r<0, L>;
+  opcode_table_cb[0x86] = &CPU::op_res_n_hl<0>;
+  opcode_table_cb[0x87] = &CPU::op_res_n_r<0, A>;
+  opcode_table_cb[0x88] = &CPU::op_res_n_r<1, B>;
+  opcode_table_cb[0x89] = &CPU::op_res_n_r<1, C>;
+  opcode_table_cb[0x8a] = &CPU::op_res_n_r<1, D>;
+  opcode_table_cb[0x8b] = &CPU::op_res_n_r<1, E>;
+  opcode_table_cb[0x8c] = &CPU::op_res_n_r<1, H>;
+  opcode_table_cb[0x8d] = &CPU::op_res_n_r<1, L>;
+  opcode_table_cb[0x8e] = &CPU::op_res_n_hl<1>;
+  opcode_table_cb[0x8f] = &CPU::op_res_n_r<1, A>;
+  opcode_table_cb[0x90] = &CPU::op_res_n_r<2, B>;
+  opcode_table_cb[0x91] = &CPU::op_res_n_r<2, C>;
+  opcode_table_cb[0x92] = &CPU::op_res_n_r<2, D>;
+  opcode_table_cb[0x93] = &CPU::op_res_n_r<2, E>;
+  opcode_table_cb[0x94] = &CPU::op_res_n_r<2, H>;
+  opcode_table_cb[0x95] = &CPU::op_res_n_r<2, L>;
+  opcode_table_cb[0x96] = &CPU::op_res_n_hl<2>;
+  opcode_table_cb[0x97] = &CPU::op_res_n_r<2, A>;
+  opcode_table_cb[0x98] = &CPU::op_res_n_r<3, B>;
+  opcode_table_cb[0x99] = &CPU::op_res_n_r<3, C>;
+  opcode_table_cb[0x9a] = &CPU::op_res_n_r<3, D>;
+  opcode_table_cb[0x9b] = &CPU::op_res_n_r<3, E>;
+  opcode_table_cb[0x9c] = &CPU::op_res_n_r<3, H>;
+  opcode_table_cb[0x9d] = &CPU::op_res_n_r<3, L>;
+  opcode_table_cb[0x9e] = &CPU::op_res_n_hl<3>;
+  opcode_table_cb[0x9f] = &CPU::op_res_n_r<3, A>;
+  opcode_table_cb[0xa0] = &CPU::op_res_n_r<4, B>;
+  opcode_table_cb[0xa1] = &CPU::op_res_n_r<4, C>;
+  opcode_table_cb[0xa2] = &CPU::op_res_n_r<4, D>;
+  opcode_table_cb[0xa3] = &CPU::op_res_n_r<4, E>;
+  opcode_table_cb[0xa4] = &CPU::op_res_n_r<4, H>;
+  opcode_table_cb[0xa5] = &CPU::op_res_n_r<4, L>;
+  opcode_table_cb[0xa6] = &CPU::op_res_n_hl<4>;
+  opcode_table_cb[0xa7] = &CPU::op_res_n_r<4, A>;
+  opcode_table_cb[0xa8] = &CPU::op_res_n_r<5, B>;
+  opcode_table_cb[0xa9] = &CPU::op_res_n_r<5, C>;
+  opcode_table_cb[0xaa] = &CPU::op_res_n_r<5, D>;
+  opcode_table_cb[0xab] = &CPU::op_res_n_r<5, E>;
+  opcode_table_cb[0xac] = &CPU::op_res_n_r<5, H>;
+  opcode_table_cb[0xad] = &CPU::op_res_n_r<5, L>;
+  opcode_table_cb[0xae] = &CPU::op_res_n_hl<5>;
+  opcode_table_cb[0xaf] = &CPU::op_res_n_r<5, A>;
+  opcode_table_cb[0xb0] = &CPU::op_res_n_r<6, B>;
+  opcode_table_cb[0xb1] = &CPU::op_res_n_r<6, C>;
+  opcode_table_cb[0xb2] = &CPU::op_res_n_r<6, D>;
+  opcode_table_cb[0xb3] = &CPU::op_res_n_r<6, E>;
+  opcode_table_cb[0xb4] = &CPU::op_res_n_r<6, H>;
+  opcode_table_cb[0xb5] = &CPU::op_res_n_r<6, L>;
+  opcode_table_cb[0xb6] = &CPU::op_res_n_hl<6>;
+  opcode_table_cb[0xb7] = &CPU::op_res_n_r<6, A>;
+  opcode_table_cb[0xb8] = &CPU::op_res_n_r<7, B>;
+  opcode_table_cb[0xb9] = &CPU::op_res_n_r<7, C>;
+  opcode_table_cb[0xba] = &CPU::op_res_n_r<7, D>;
+  opcode_table_cb[0xbb] = &CPU::op_res_n_r<7, E>;
+  opcode_table_cb[0xbc] = &CPU::op_res_n_r<7, H>;
+  opcode_table_cb[0xbd] = &CPU::op_res_n_r<7, L>;
+  opcode_table_cb[0xbe] = &CPU::op_res_n_hl<7>;
+  opcode_table_cb[0xbf] = &CPU::op_res_n_r<7, A>;
+  opcode_table_cb[0xc0] = &CPU::op_set_n_r<0, B>;
+  opcode_table_cb[0xc1] = &CPU::op_set_n_r<0, C>;
+  opcode_table_cb[0xc2] = &CPU::op_set_n_r<0, D>;
+  opcode_table_cb[0xc3] = &CPU::op_set_n_r<0, E>;
+  opcode_table_cb[0xc4] = &CPU::op_set_n_r<0, H>;
+  opcode_table_cb[0xc5] = &CPU::op_set_n_r<0, L>;
+  opcode_table_cb[0xc6] = &CPU::op_set_n_hl<0>;
+  opcode_table_cb[0xc7] = &CPU::op_set_n_r<0, A>;
+  opcode_table_cb[0xc8] = &CPU::op_set_n_r<1, B>;
+  opcode_table_cb[0xc9] = &CPU::op_set_n_r<1, C>;
+  opcode_table_cb[0xca] = &CPU::op_set_n_r<1, D>;
+  opcode_table_cb[0xcb] = &CPU::op_set_n_r<1, E>;
+  opcode_table_cb[0xcc] = &CPU::op_set_n_r<1, H>;
+  opcode_table_cb[0xcd] = &CPU::op_set_n_r<1, L>;
+  opcode_table_cb[0xce] = &CPU::op_set_n_hl<1>;
+  opcode_table_cb[0xcf] = &CPU::op_set_n_r<1, A>;
+  opcode_table_cb[0xd0] = &CPU::op_set_n_r<2, B>;
+  opcode_table_cb[0xd1] = &CPU::op_set_n_r<2, C>;
+  opcode_table_cb[0xd2] = &CPU::op_set_n_r<2, D>;
+  opcode_table_cb[0xd3] = &CPU::op_set_n_r<2, E>;
+  opcode_table_cb[0xd4] = &CPU::op_set_n_r<2, H>;
+  opcode_table_cb[0xd5] = &CPU::op_set_n_r<2, L>;
+  opcode_table_cb[0xd6] = &CPU::op_set_n_hl<2>;
+  opcode_table_cb[0xd7] = &CPU::op_set_n_r<2, A>;
+  opcode_table_cb[0xd8] = &CPU::op_set_n_r<3, B>;
+  opcode_table_cb[0xd9] = &CPU::op_set_n_r<3, C>;
+  opcode_table_cb[0xda] = &CPU::op_set_n_r<3, D>;
+  opcode_table_cb[0xdb] = &CPU::op_set_n_r<3, E>;
+  opcode_table_cb[0xdc] = &CPU::op_set_n_r<3, H>;
+  opcode_table_cb[0xdd] = &CPU::op_set_n_r<3, L>;
+  opcode_table_cb[0xde] = &CPU::op_set_n_hl<3>;
+  opcode_table_cb[0xdf] = &CPU::op_set_n_r<3, A>;
+  opcode_table_cb[0xe0] = &CPU::op_set_n_r<4, B>;
+  opcode_table_cb[0xe1] = &CPU::op_set_n_r<4, C>;
+  opcode_table_cb[0xe2] = &CPU::op_set_n_r<4, D>;
+  opcode_table_cb[0xe3] = &CPU::op_set_n_r<4, E>;
+  opcode_table_cb[0xe4] = &CPU::op_set_n_r<4, H>;
+  opcode_table_cb[0xe5] = &CPU::op_set_n_r<4, L>;
+  opcode_table_cb[0xe6] = &CPU::op_set_n_hl<4>;
+  opcode_table_cb[0xe7] = &CPU::op_set_n_r<4, A>;
+  opcode_table_cb[0xe8] = &CPU::op_set_n_r<5, B>;
+  opcode_table_cb[0xe9] = &CPU::op_set_n_r<5, C>;
+  opcode_table_cb[0xea] = &CPU::op_set_n_r<5, D>;
+  opcode_table_cb[0xeb] = &CPU::op_set_n_r<5, E>;
+  opcode_table_cb[0xec] = &CPU::op_set_n_r<5, H>;
+  opcode_table_cb[0xed] = &CPU::op_set_n_r<5, L>;
+  opcode_table_cb[0xee] = &CPU::op_set_n_hl<5>;
+  opcode_table_cb[0xef] = &CPU::op_set_n_r<5, A>;
+  opcode_table_cb[0xf0] = &CPU::op_set_n_r<6, B>;
+  opcode_table_cb[0xf1] = &CPU::op_set_n_r<6, C>;
+  opcode_table_cb[0xf2] = &CPU::op_set_n_r<6, D>;
+  opcode_table_cb[0xf3] = &CPU::op_set_n_r<6, E>;
+  opcode_table_cb[0xf4] = &CPU::op_set_n_r<6, H>;
+  opcode_table_cb[0xf5] = &CPU::op_set_n_r<6, L>;
+  opcode_table_cb[0xf6] = &CPU::op_set_n_hl<6>;
+  opcode_table_cb[0xf7] = &CPU::op_set_n_r<6, A>;
+  opcode_table_cb[0xf8] = &CPU::op_set_n_r<7, B>;
+  opcode_table_cb[0xf9] = &CPU::op_set_n_r<7, C>;
+  opcode_table_cb[0xfa] = &CPU::op_set_n_r<7, D>;
+  opcode_table_cb[0xfb] = &CPU::op_set_n_r<7, E>;
+  opcode_table_cb[0xfc] = &CPU::op_set_n_r<7, H>;
+  opcode_table_cb[0xfd] = &CPU::op_set_n_r<7, L>;
+  opcode_table_cb[0xfe] = &CPU::op_set_n_hl<7>;
+  opcode_table_cb[0xff] = &CPU::op_set_n_r<7, A>;
+}
+
+#endif

bsnes/gameboy/cpu/cpu.cpp

@@ -0,0 +1,162 @@
+#include <gameboy/gameboy.hpp>
+
+#define CPU_CPP
+namespace GameBoy {
+
+#include "core/core.cpp"
+#include "mmio/mmio.cpp"
+#include "timing/timing.cpp"
+#include "serialization.cpp"
+CPU cpu;
+
+void CPU::Main() {
+  cpu.main();
+}
+
+void CPU::main() {
+  while(true) {
+    if(scheduler.sync == Scheduler::SynchronizeMode::CPU) {
+      scheduler.sync = Scheduler::SynchronizeMode::All;
+      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
+    }
+
+    if(trace) print(disassemble(r[PC]), "\n");
+    interrupt_test();
+    uint8 opcode = op_read(r[PC]++);
+    (this->*opcode_table[opcode])();
+  }
+}
+
+void CPU::interrupt_raise(CPU::Interrupt id) {
+  if(id == Interrupt::Vblank) {
+    status.interrupt_request_vblank = 1;
+    if(status.interrupt_enable_vblank) status.halt = false;
+  }
+
+  if(id == Interrupt::Stat) {
+    status.interrupt_request_stat = 1;
+    if(status.interrupt_enable_stat) status.halt = false;
+  }
+
+  if(id == Interrupt::Timer) {
+    status.interrupt_request_timer = 1;
+    if(status.interrupt_enable_timer) status.halt = false;
+  }
+
+  if(id == Interrupt::Serial) {
+    status.interrupt_request_serial = 1;
+    if(status.interrupt_enable_serial) status.halt = false;
+  }
+
+  if(id == Interrupt::Joypad) {
+    status.interrupt_request_joypad = 1;
+    if(status.interrupt_enable_joypad) status.halt = status.stop = false;
+  }
+}
+
+void CPU::interrupt_test() {
+  if(status.ime) {
+    if(status.interrupt_request_vblank && status.interrupt_enable_vblank) {
+      status.interrupt_request_vblank = 0;
+      return interrupt_exec(0x0040);
+    }
+
+    if(status.interrupt_request_stat && status.interrupt_enable_stat) {
+      status.interrupt_request_stat = 0;
+      return interrupt_exec(0x0048);
+    }
+
+    if(status.interrupt_request_timer && status.interrupt_enable_timer) {
+      status.interrupt_request_timer = 0;
+      return interrupt_exec(0x0050);
+    }
+
+    if(status.interrupt_request_serial && status.interrupt_enable_serial) {
+      status.interrupt_request_serial = 0;
+      return interrupt_exec(0x0058);
+    }
+
+    if(status.interrupt_request_joypad && status.interrupt_enable_joypad) {
+      status.interrupt_request_joypad = 0;
+      return interrupt_exec(0x0060);
+    }
+  }
+}
+
+void CPU::interrupt_exec(uint16 pc) {
+  status.ime = 0;
+  op_write(--r[SP], r[PC] >> 8);
+  op_write(--r[SP], r[PC] >> 0);
+  r[PC] = pc;
+  op_io();
+  op_io();
+  op_io();
+}
+
+void CPU::power() {
+  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 = 0; n < 8192; n++) wram[n] = 0x00;
+  for(unsigned n = 0; n <  128; n++) hram[n] = 0x00;
+
+  r[PC] = 0x0000;
+  r[SP] = 0x0000;
+  r[AF] = 0x0000;
+  r[BC] = 0x0000;
+  r[DE] = 0x0000;
+  r[HL] = 0x0000;
+
+  status.clock = 0;
+  status.halt = false;
+  status.stop = false;
+
+  status.ime = 0;
+  status.timer0 = 0;
+  status.timer1 = 0;
+  status.timer2 = 0;
+  status.timer3 = 0;
+  status.timer4 = 0;
+
+  status.p15 = 0;
+  status.p14 = 0;
+  status.joyp = 0;
+  status.mlt_req = 0;
+
+  status.serial_data = 0;
+  status.serial_bits = 0;
+
+  status.serial_transfer = 0;
+  status.serial_clock = 0;
+
+  status.div = 0;
+
+  status.tima = 0;
+
+  status.tma = 0;
+
+  status.timer_enable = 0;
+  status.timer_clock = 0;
+
+  status.interrupt_request_joypad = 0;
+  status.interrupt_request_serial = 0;
+  status.interrupt_request_timer = 0;
+  status.interrupt_request_stat = 0;
+  status.interrupt_request_vblank = 0;
+
+  status.interrupt_enable_joypad = 0;
+  status.interrupt_enable_serial = 0;
+  status.interrupt_enable_timer = 0;
+  status.interrupt_enable_stat = 0;
+  status.interrupt_enable_vblank = 0;
+}
+
+CPU::CPU() : trace(false) {
+  initialize_opcode_table();
+}
+
+}

bsnes/gameboy/cpu/cpu.hpp

@@ -0,0 +1,84 @@
+struct CPU : Processor, MMIO {
+  #include "core/core.hpp"
+  #include "mmio/mmio.hpp"
+  #include "timing/timing.hpp"
+
+  bool trace;
+
+  enum class Interrupt : unsigned {
+    Vblank,
+    Stat,
+    Timer,
+    Serial,
+    Joypad,
+  };
+
+  struct Status {
+    unsigned clock;
+    bool halt;
+    bool stop;
+
+    bool ime;
+    unsigned timer0;
+    unsigned timer1;
+    unsigned timer2;
+    unsigned timer3;
+    unsigned timer4;
+
+    //$ff00  JOYP
+    bool p15;
+    bool p14;
+    uint8 joyp;
+    uint8 mlt_req;
+
+    //$ff01  SB
+    uint8 serial_data;
+    unsigned serial_bits;
+
+    //$ff02  SC
+    bool serial_transfer;
+    bool serial_clock;
+
+    //$ff04  DIV
+    uint8 div;
+
+    //$ff05  TIMA
+    uint8 tima;
+
+    //$ff06  TMA
+    uint8 tma;
+
+    //$ff07  TAC
+    bool timer_enable;
+    unsigned timer_clock;
+
+    //$ff0f  IF
+    bool interrupt_request_joypad;
+    bool interrupt_request_serial;
+    bool interrupt_request_timer;
+    bool interrupt_request_stat;
+    bool interrupt_request_vblank;
+
+    //$ffff  IE
+    bool interrupt_enable_joypad;
+    bool interrupt_enable_serial;
+    bool interrupt_enable_timer;
+    bool interrupt_enable_stat;
+    bool interrupt_enable_vblank;
+  } status;
+
+  uint8 wram[8192];
+  uint8 hram[128];
+
+  static void Main();
+  void main();
+  void interrupt_raise(Interrupt id);
+  void interrupt_test();
+  void interrupt_exec(uint16 pc);
+  void power();
+
+  void serialize(serializer&);
+  CPU();
+};
+
+extern CPU cpu;

bsnes/gameboy/cpu/mmio/mmio.cpp

@@ -0,0 +1,144 @@
+#ifdef CPU_CPP
+
+void CPU::mmio_joyp_poll() {
+  unsigned button = 0, dpad = 0;
+
+  button |= system.interface->input_poll((unsigned)Input::Start) << 3;
+  button |= system.interface->input_poll((unsigned)Input::Select) << 2;
+  button |= system.interface->input_poll((unsigned)Input::B) << 1;
+  button |= system.interface->input_poll((unsigned)Input::A) << 0;
+
+  dpad |= system.interface->input_poll((unsigned)Input::Down) << 3;
+  dpad |= system.interface->input_poll((unsigned)Input::Up) << 2;
+  dpad |= system.interface->input_poll((unsigned)Input::Left) << 1;
+  dpad |= system.interface->input_poll((unsigned)Input::Right) << 0;
+
+  status.joyp = 0x0f;
+  if(status.p15 == 1 && status.p14 == 1) status.joyp -= status.mlt_req;
+  if(status.p15 == 0) status.joyp &= button ^ 0x0f;
+  if(status.p14 == 0) status.joyp &= dpad ^ 0x0f;
+  if(status.joyp != 0x0f) interrupt_raise(Interrupt::Joypad);
+}
+
+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 >= 0xff80 && addr <= 0xfffe) return hram[addr & 0x7f];
+
+  if(addr == 0xff00) {  //JOYP
+    return (status.p15 << 5)
+         | (status.p14 << 4)
+         | (status.joyp << 0);
+  }
+
+  if(addr == 0xff01) {  //SB
+    return 0xff;
+  }
+
+  if(addr == 0xff02) {  //SC
+    return (status.serial_transfer << 7)
+         | (status.serial_clock << 0);
+  }
+
+  if(addr == 0xff04) {  //DIV
+    return status.div;
+  }
+
+  if(addr == 0xff05) {  //TIMA
+    return status.tima;
+  }
+
+  if(addr == 0xff06) {  //TMA
+    return status.tma;
+  }
+
+  if(addr == 0xff07) {  //TAC
+    return (status.timer_enable << 2)
+         | (status.timer_clock << 0);
+  }
+
+  if(addr == 0xff0f) {  //IF
+    return (status.interrupt_request_joypad << 4)
+         | (status.interrupt_request_serial << 3)
+         | (status.interrupt_request_timer << 2)
+         | (status.interrupt_request_stat << 1)
+         | (status.interrupt_request_vblank << 0);
+  }
+
+  if(addr == 0xffff) {  //IE
+    return (status.interrupt_enable_joypad << 4)
+         | (status.interrupt_enable_serial << 3)
+         | (status.interrupt_enable_timer << 2)
+         | (status.interrupt_enable_stat << 1)
+         | (status.interrupt_enable_vblank << 0);
+  }
+
+  return 0x00;
+}
+
+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 >= 0xff80 && addr <= 0xfffe) { hram[addr & 0x7f] = data; return; }
+
+  if(addr == 0xff00) {  //JOYP
+    status.p15 = data & 0x20;
+    status.p14 = data & 0x10;
+    system.interface->joyp_write(status.p15, status.p14);
+    mmio_joyp_poll();
+    return;
+  }
+
+  if(addr == 0xff01) {  //SB
+    status.serial_data = data;
+    return;
+  }
+
+  if(addr == 0xff02) {  //SC
+    status.serial_transfer = data & 0x80;
+    status.serial_clock = data & 0x01;
+    if(status.serial_transfer) status.serial_bits = 8;
+    return;
+  }
+
+  if(addr == 0xff04) {  //DIV
+    status.div = 0;
+    return;
+  }
+
+  if(addr == 0xff05) {  //TIMA
+    status.tima = data;
+    return;
+  }
+
+  if(addr == 0xff06) {  //TMA
+    status.tma = data;
+    return;
+  }
+
+  if(addr == 0xff07) {  //TAC
+    status.timer_enable = data & 0x04;
+    status.timer_clock = data & 0x03;
+    return;
+  }
+
+  if(addr == 0xff0f) {  //IF
+    status.interrupt_request_joypad = data & 0x10;
+    status.interrupt_request_serial = data & 0x08;
+    status.interrupt_request_timer = data & 0x04;
+    status.interrupt_request_stat = data & 0x02;
+    status.interrupt_request_vblank = data & 0x01;
+    return;
+  }
+
+  if(addr == 0xffff) {  //IE
+    status.interrupt_enable_joypad = data & 0x10;
+    status.interrupt_enable_serial = data & 0x08;
+    status.interrupt_enable_timer = data & 0x04;
+    status.interrupt_enable_stat = data & 0x02;
+    status.interrupt_enable_vblank = data & 0x01;
+    return;
+  }
+}
+
+#endif

bsnes/gameboy/cpu/mmio/mmio.hpp

@@ -0,0 +1,3 @@
+void mmio_joyp_poll();
+uint8 mmio_read(uint16 addr);
+void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/cpu/serialization.cpp

@@ -0,0 +1,62 @@
+#ifdef CPU_CPP
+
+void CPU::serialize(serializer &s) {
+  s.array(wram);
+  s.array(hram);
+
+  s.integer(r.a.data);
+  s.integer(r.f.z);
+  s.integer(r.f.n);
+  s.integer(r.f.h);
+  s.integer(r.f.c);
+  s.integer(r.b.data);
+  s.integer(r.c.data);
+  s.integer(r.d.data);
+  s.integer(r.e.data);
+  s.integer(r.h.data);
+  s.integer(r.l.data);
+  s.integer(r.sp.data);
+  s.integer(r.pc.data);
+
+  s.integer(status.clock);
+  s.integer(status.halt);
+  s.integer(status.stop);
+
+  s.integer(status.ime);
+  s.integer(status.timer0);
+  s.integer(status.timer1);
+  s.integer(status.timer2);
+  s.integer(status.timer3);
+  s.integer(status.timer4);
+
+  s.integer(status.p15);
+  s.integer(status.p14);
+  s.integer(status.joyp);
+  s.integer(status.mlt_req);
+
+  s.integer(status.serial_data);
+  s.integer(status.serial_bits);
+
+  s.integer(status.serial_transfer);
+  s.integer(status.serial_clock);
+
+  s.integer(status.div);
+  s.integer(status.tima);
+  s.integer(status.tma);
+  s.integer(status.timer_enable);
+  s.integer(status.timer_clock);
+
+  s.integer(status.interrupt_request_joypad);
+  s.integer(status.interrupt_request_serial);
+  s.integer(status.interrupt_request_timer);
+  s.integer(status.interrupt_request_stat);
+  s.integer(status.interrupt_request_vblank);
+
+  s.integer(status.interrupt_enable_joypad);
+  s.integer(status.interrupt_enable_serial);
+  s.integer(status.interrupt_enable_timer);
+  s.integer(status.interrupt_enable_stat);
+  s.integer(status.interrupt_enable_vblank);
+}
+
+#endif

bsnes/gameboy/cpu/timing/opcode.cpp

@@ -0,0 +1,18 @@
+#ifdef CPU_CPP
+
+void CPU::op_io() {
+  add_clocks(4);
+}
+
+uint8 CPU::op_read(uint16 addr) {
+  uint8 r = bus.read(addr);
+  add_clocks(4);
+  return r;
+}
+
+void CPU::op_write(uint16 addr, uint8 data) {
+  bus.write(addr, data);
+  add_clocks(4);
+}
+
+#endif

bsnes/gameboy/cpu/timing/timing.cpp

@@ -0,0 +1,93 @@
+//4194304hz (4 * 1024 * 1024)
+//70224 clocks/frame
+//  456 clocks/scanline
+//  154 scanlines/frame
+
+//4194304 /   4096 = 1024
+//4194304 / 262144 =   16
+//4194304 /  65536 =   64
+//4394304 /  16384 =  256
+
+#ifdef CPU_CPP
+
+#include "opcode.cpp"
+
+void CPU::add_clocks(unsigned clocks) {
+  system.clocks_executed += clocks;
+  scheduler.exit(Scheduler::ExitReason::StepEvent);
+
+  status.clock += clocks;
+  if(status.clock >= 4 * 1024 * 1024) {
+    status.clock -= 4 * 1024 * 1024;
+    cartridge.mbc3.second();
+  }
+
+  status.timer0 += clocks;
+  if(status.timer0 >= 16) timer_stage0();
+
+  cpu.clock += clocks;
+  if(cpu.clock >= 0) co_switch(scheduler.active_thread = lcd.thread);
+}
+
+void CPU::timer_stage0() {  //262144hz
+  if(status.timer_enable && status.timer_clock == 1) {
+    if(++status.tima == 0) {
+      status.tima = status.tma;
+      interrupt_raise(Interrupt::Timer);
+    }
+  }
+
+  status.timer0 -= 16;
+  if(++status.timer1 >= 4) timer_stage1();
+}
+
+void CPU::timer_stage1() {  // 65536hz
+  if(status.timer_enable && status.timer_clock == 2) {
+    if(++status.tima == 0) {
+      status.tima = status.tma;
+      interrupt_raise(Interrupt::Timer);
+    }
+  }
+
+  status.timer1 -= 4;
+  if(++status.timer2 >= 4) timer_stage2();
+}
+
+void CPU::timer_stage2() {  // 16384hz
+  if(status.timer_enable && status.timer_clock == 3) {
+    if(++status.tima == 0) {
+      status.tima = status.tma;
+      interrupt_raise(Interrupt::Timer);
+    }
+  }
+
+  status.div++;
+
+  status.timer2 -= 4;
+  if(++status.timer3 >= 2) timer_stage3();
+}
+
+void CPU::timer_stage3() {  //  8192hz
+  if(status.serial_transfer && status.serial_clock) {
+    if(--status.serial_bits == 0) {
+      status.serial_transfer = 0;
+      interrupt_raise(Interrupt::Serial);
+    }
+  }
+
+  status.timer3 -= 2;
+  if(++status.timer4 >= 2) timer_stage4();
+}
+
+void CPU::timer_stage4() {  //  4096hz
+  if(status.timer_enable && status.timer_clock == 0) {
+    if(++status.tima == 0) {
+      status.tima = status.tma;
+      interrupt_raise(Interrupt::Timer);
+    }
+  }
+
+  status.timer4 -= 2;
+}
+
+#endif

bsnes/gameboy/cpu/timing/timing.hpp

@@ -0,0 +1,11 @@
+void add_clocks(unsigned clocks);
+void timer_stage0();
+void timer_stage1();
+void timer_stage2();
+void timer_stage3();
+void timer_stage4();
+
+//opcode.cpp
+void op_io();
+uint8 op_read(uint16 addr);
+void op_write(uint16 addr, uint8 data);

bsnes/gameboy/gameboy.hpp

@@ -0,0 +1,62 @@
+//bgameboy
+//author: byuu
+//project started: 2010-12-27
+
+namespace GameBoy {
+  namespace Info {
+    static const char Name[] = "bgameboy";
+    static const char Version[] = "000.13";
+    static unsigned SerializerVersion = 1;
+  }
+}
+
+#include <libco/libco.h>
+
+#include <nall/foreach.hpp>
+#include <nall/platform.hpp>
+#include <nall/property.hpp>
+#include <nall/serializer.hpp>
+#include <nall/stdint.hpp>
+#include <nall/string.hpp>
+using namespace nall;
+
+namespace GameBoy {
+  typedef int8_t   int8;
+  typedef int16_t  int16;
+  typedef int32_t  int32;
+  typedef int64_t  int64;
+
+  typedef uint8_t  uint8;
+  typedef uint16_t uint16;
+  typedef uint32_t uint32;
+  typedef uint64_t uint64;
+
+  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_) {
+      if(thread) co_delete(thread);
+      thread = co_create(65536 * sizeof(void*), entrypoint_);
+      frequency = frequency_;
+      clock = 0;
+    }
+
+    inline Processor() : thread(0) {}
+  };
+
+  #include <gameboy/memory/memory.hpp>
+  #include <gameboy/system/system.hpp>
+  #include <gameboy/scheduler/scheduler.hpp>
+  #include <gameboy/cartridge/cartridge.hpp>
+  #include <gameboy/cpu/cpu.hpp>
+  #include <gameboy/apu/apu.hpp>
+  #include <gameboy/lcd/lcd.hpp>
+};

bsnes/gameboy/interface/interface.hpp

@@ -0,0 +1,11 @@
+class Interface {
+public:
+  virtual void joyp_write(bool p15, bool p14) {}
+
+  virtual void video_refresh(const uint8_t *data) {}
+  virtual void audio_sample(signed left, signed right) {}
+  virtual void input_poll() {}
+  virtual bool input_poll(unsigned id) {}
+
+  virtual void message(const string &text) { print(text, "\n"); }
+};

bsnes/gameboy/lcd/lcd.cpp

@@ -0,0 +1,238 @@
+#include <gameboy/gameboy.hpp>
+
+#define LCD_CPP
+namespace GameBoy {
+
+#include "mmio/mmio.cpp"
+#include "serialization.cpp"
+LCD lcd;
+
+void LCD::Main() {
+  lcd.main();
+}
+
+void LCD::main() {
+  while(true) {
+    if(scheduler.sync == Scheduler::SynchronizeMode::All) {
+      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
+    }
+
+    add_clocks(4);
+
+    if(status.lx == 0) {
+      if(status.interrupt_oam) cpu.interrupt_raise(CPU::Interrupt::Stat);
+    }
+
+    if(status.lx == 252) {
+      if(status.interrupt_hblank) cpu.interrupt_raise(CPU::Interrupt::Stat);
+    }
+  }
+}
+
+void LCD::add_clocks(unsigned clocks) {
+  status.lx += clocks;
+  if(status.lx >= 456) scanline();
+
+  cpu.clock -= clocks;
+  if(cpu.clock <= 0 && scheduler.sync != Scheduler::SynchronizeMode::All) {
+    co_switch(scheduler.active_thread = cpu.thread);
+  }
+}
+
+void LCD::scanline() {
+  status.lx -= 456;
+  if(++status.ly == 154) frame();
+
+  if(status.interrupt_lyc == true) {
+    if(status.ly == status.lyc) cpu.interrupt_raise(CPU::Interrupt::Stat);
+  }
+
+  if(status.ly < 144) render();
+
+  if(status.ly == 144) {
+    cpu.interrupt_raise(CPU::Interrupt::Vblank);
+    if(status.interrupt_vblank) cpu.interrupt_raise(CPU::Interrupt::Stat);
+  }
+}
+
+void LCD::frame() {
+  system.interface->video_refresh(screen);
+  system.interface->input_poll();
+  cpu.mmio_joyp_poll();
+
+  status.ly = 0;
+  scheduler.exit(Scheduler::ExitReason::FrameEvent);
+}
+
+void LCD::render() {
+  for(unsigned n = 0; n < 160; n++) line[n] = 0x00;
+
+  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] = (3 - line[n]) * 0x55;
+}
+
+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];
+
+    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;
+  unsigned iy = status.ly - status.wy;
+  unsigned ix = (status.wx - 7) & 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];
+
+    ix = (ix + 1) & 255;
+    tx = (tx + 1) & 7;
+
+    if(tx == 0) data = read_tile(status.window_tilemap_select, ix, iy);
+  }
+}
+
+void LCD::render_obj() {
+  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 & 0x40) sy ^= (obj_size - 1);
+
+    unsigned tdaddr = (tile << 4) + (sy << 1);
+    uint8 d0 = vram[tdaddr + 0];
+    uint8 d1 = vram[tdaddr + 1];
+    unsigned xflip = attribute & 0x20 ? 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 & 0x10)][palette];
+      unsigned ox = sx + (tx ^ xflip);
+
+      if(ox <= 159) {
+        if(attribute & 0x80) {
+          if(line[ox] > 0) continue;
+        }
+        line[ox] = palette;
+      }
+    }
+  }
+}
+
+void LCD::power() {
+  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;
+
+  for(unsigned n = 0; n < 160 * 144; n++) screen[n] = 0x00;
+
+  status.lx = 0;
+
+  status.display_enable = 0;
+  status.window_tilemap_select = 0;
+  status.window_display_enable = 0;
+  status.bg_tiledata_select = 0;
+  status.bg_tilemap_select = 0;
+  status.obj_size = 0;
+  status.obj_enable = 0;
+  status.bg_enable = 0;
+
+  status.interrupt_lyc = 0;
+  status.interrupt_oam = 0;
+  status.interrupt_vblank = 0;
+  status.interrupt_hblank = 0;
+
+  status.scy = 0;
+  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;
+}
+
+LCD::LCD() {
+}
+
+}

bsnes/gameboy/lcd/lcd.hpp

@@ -0,0 +1,71 @@
+struct LCD : Processor, MMIO {
+  #include "mmio/mmio.hpp"
+
+  struct Status {
+    unsigned lx;
+
+    //$ff40  LCDC
+    bool display_enable;
+    bool window_tilemap_select;
+    bool window_display_enable;
+    bool bg_tiledata_select;
+    bool bg_tilemap_select;
+    bool obj_size;
+    bool obj_enable;
+    bool bg_enable;
+
+    //$ff41  STAT
+    bool interrupt_lyc;
+    bool interrupt_oam;
+    bool interrupt_vblank;
+    bool interrupt_hblank;
+
+    //$ff42  SCY
+    uint8 scy;
+
+    //$ff43  SCX
+    uint8 scx;
+
+    //$ff44  LY
+    uint8 ly;
+
+    //$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;
+  } status;
+
+  uint8 screen[160 * 144];
+  uint8 vram[8192];
+  uint8 oam[160];
+  uint8 line[160];
+
+  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();
+
+  void power();
+
+  void serialize(serializer&);
+  LCD();
+};
+
+extern LCD lcd;

bsnes/gameboy/lcd/mmio/mmio.cpp

@@ -0,0 +1,165 @@
+#ifdef LCD_CPP
+
+uint8 LCD::mmio_read(uint16 addr) {
+  if(addr >= 0x8000 && addr <= 0x9fff) return vram[addr & 0x1fff];
+  if(addr >= 0xfe00 && addr <= 0xfe9f) return oam[addr & 0xff];
+
+  if(addr == 0xff40) {  //LCDC
+    return (status.display_enable << 7)
+         | (status.window_tilemap_select << 6)
+         | (status.window_display_enable << 5)
+         | (status.bg_tiledata_select << 4)
+         | (status.bg_tilemap_select << 3)
+         | (status.obj_size << 2)
+         | (status.obj_enable << 1)
+         | (status.bg_enable << 0);
+  }
+
+  if(addr == 0xff41) {  //STAT
+    unsigned mode;
+    if(status.ly >= 144) mode = 1;      //Vblank
+    else if(status.lx < 80) mode = 2;   //OAM
+    else if(status.lx < 252) mode = 3;  //LCD
+    else mode = 0;                      //Hblank
+
+    return (status.interrupt_lyc << 6)
+         | (status.interrupt_oam << 5)
+         | (status.interrupt_vblank << 4)
+         | (status.interrupt_hblank << 3)
+         | ((status.ly == status.lyc) << 2)
+         | (mode << 0);
+  }
+
+  if(addr == 0xff42) {  //SCY
+    return status.scy;
+  }
+
+  if(addr == 0xff43) {  //SCX
+    return status.scx;
+  }
+
+  if(addr == 0xff44) {  //LY
+    return status.ly;
+  }
+
+  if(addr == 0xff45) {  //LYC
+    return status.lyc;
+  }
+
+  if(addr == 0xff47) {  //BGP
+    return (status.bgp[3] << 6)
+         | (status.bgp[2] << 4)
+         | (status.bgp[1] << 2)
+         | (status.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);
+  }
+
+  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);
+  }
+
+  if(addr == 0xff4a) {  //WY
+    return status.wy;
+  }
+
+  if(addr == 0xff4b) {  //WX
+    return status.wx;
+  }
+
+  return 0x00;
+}
+
+void LCD::mmio_write(uint16 addr, uint8 data) {
+  if(addr >= 0x8000 && addr <= 0x9fff) { vram[addr & 0x1fff] = data; return; }
+  if(addr >= 0xfe00 && addr <= 0xfe9f) { oam[addr & 0xff] = data; return; }
+
+  if(addr == 0xff40) {  //LCDC
+    status.display_enable = data & 0x80;
+    status.window_tilemap_select = data & 0x40;
+    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.bg_enable = data & 0x01;
+    return;
+  }
+
+  if(addr == 0xff41) {  //STAT
+    status.interrupt_lyc = data & 0x40;
+    status.interrupt_oam = data & 0x20;
+    status.interrupt_vblank = data & 0x10;
+    status.interrupt_hblank = data & 0x08;
+    return;
+  }
+
+  if(addr == 0xff42) {  //SCY
+    status.scy = data;
+    return;
+  }
+
+  if(addr == 0xff43) {  //SCX
+    status.scx = data;
+    return;
+  }
+
+  if(addr == 0xff44) {  //LY
+    status.ly = 0;
+    return;
+  }
+
+  if(addr == 0xff45) {  //LYC
+    status.lyc = 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;
+    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;
+    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;
+    return;
+  }
+
+  if(addr == 0xff4a) {  //WY
+    status.wy = data;
+    return;
+  }
+
+  if(addr == 0xff4b) {  //WX
+    status.wx = data;
+    return;
+  }
+}
+
+#endif

bsnes/gameboy/lcd/mmio/mmio.hpp

@@ -0,0 +1,2 @@
+uint8 mmio_read(uint16 addr);
+void mmio_write(uint16 addr, uint8 data);

bsnes/gameboy/lcd/serialization.cpp

@@ -0,0 +1,38 @@
+#ifdef LCD_CPP
+
+void LCD::serialize(serializer &s) {
+  s.integer(status.lx);
+
+  s.integer(status.display_enable);
+  s.integer(status.window_tilemap_select);
+  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.bg_enable);
+
+  s.integer(status.interrupt_lyc);
+  s.integer(status.interrupt_oam);
+  s.integer(status.interrupt_vblank);
+  s.integer(status.interrupt_hblank);
+
+  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);
+}
+
+#endif

bsnes/gameboy/memory/memory.cpp

@@ -0,0 +1,56 @@
+#include <gameboy/gameboy.hpp>
+
+#define MEMORY_CPP
+namespace GameBoy {
+
+Unmapped unmapped;
+Bus bus;
+
+uint8_t& Memory::operator[](unsigned addr) {
+  return data[addr];
+}
+
+void Memory::allocate(unsigned size_) {
+  free();
+  size = size_;
+  data = new uint8_t[size]();
+}
+
+void Memory::copy(const uint8_t *data_, unsigned size_) {
+  free();
+  size = size_;
+  data = new uint8_t[size];
+  memcpy(data, data_, size);
+}
+
+void Memory::free() {
+  if(data) {
+    delete[] data;
+    data = 0;
+  }
+}
+
+Memory::Memory() {
+  data = 0;
+  size = 0;
+}
+
+Memory::~Memory() {
+  free();
+}
+
+//
+
+uint8 Bus::read(uint16 addr) {
+  return mmio[addr]->mmio_read(addr);
+}
+
+void Bus::write(uint16 addr, uint8 data) {
+  mmio[addr]->mmio_write(addr, data);
+}
+
+void Bus::power() {
+  for(unsigned n = 0; n < 65536; n++) mmio[n] = &unmapped;
+}
+
+}

bsnes/gameboy/memory/memory.hpp

@@ -0,0 +1,32 @@
+struct Memory {
+  uint8_t *data;
+  unsigned size;
+
+  uint8_t& operator[](unsigned addr);
+  void allocate(unsigned size);
+  void copy(const uint8_t *data, unsigned size);
+  void free();
+  Memory();
+  ~Memory();
+};
+
+struct MMIO {
+  virtual uint8 mmio_read(uint16 addr) = 0;
+  virtual void mmio_write(uint16 addr, uint8 data) = 0;
+};
+
+struct Unmapped : MMIO {
+  uint8 mmio_read(uint16) { return 0x00; }
+  void mmio_write(uint16, uint8) {}
+};
+
+struct Bus {
+  MMIO *mmio[65536];
+  uint8 read(uint16 addr);
+  void write(uint16 addr, uint8 data);
+
+  void power();
+};
+
+extern Unmapped unmapped;
+extern Bus bus;

bsnes/gameboy/scheduler/scheduler.cpp

@@ -0,0 +1,35 @@
+#include <gameboy/gameboy.hpp>
+
+#define SCHEDULER_CPP
+namespace GameBoy {
+
+Scheduler scheduler;
+
+void Scheduler::enter() {
+  host_thread = co_active();
+  co_switch(active_thread);
+}
+
+void Scheduler::exit(ExitReason reason) {
+  exit_reason = reason;
+  active_thread = co_active();
+  co_switch(host_thread);
+}
+
+void Scheduler::swapto(Processor &p) {
+  active_thread = p.thread;
+  co_switch(active_thread);
+}
+
+void Scheduler::init() {
+  host_thread = co_active();
+  active_thread = cpu.thread;
+}
+
+Scheduler::Scheduler() {
+  exit_reason = ExitReason::UnknownEvent;
+  host_thread = 0;
+  active_thread = 0;
+}
+
+}

bsnes/gameboy/scheduler/scheduler.hpp

@@ -0,0 +1,17 @@
+struct Scheduler : property<Scheduler> {
+  enum class SynchronizeMode : unsigned { None, CPU, All } sync;
+  enum class ExitReason : unsigned { UnknownEvent, StepEvent, FrameEvent, SynchronizeEvent };
+  readonly<ExitReason> exit_reason;
+
+  cothread_t host_thread;
+  cothread_t active_thread;
+
+  void enter();
+  void exit(ExitReason);
+  void swapto(Processor&);
+
+  void init();
+  Scheduler();
+};
+
+extern Scheduler scheduler;

bsnes/gameboy/system/bootrom-dmg.cpp

@@ -0,0 +1,23 @@
+#ifdef SYSTEM_CPP
+
+//MD5SUM = 32fbbd84168d3482956eb3c5051637f5
+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,
+  0x47,0x11,0x04,0x01,0x21,0x10,0x80,0x1a,0xcd,0x95,0x00,0xcd,0x96,0x00,0x13,0x7b,
+  0xfe,0x34,0x20,0xf3,0x11,0xd8,0x00,0x06,0x08,0x1a,0x13,0x22,0x23,0x05,0x20,0xf9,
+  0x3e,0x19,0xea,0x10,0x99,0x21,0x2f,0x99,0x0e,0x0c,0x3d,0x28,0x08,0x32,0x0d,0x20,
+  0xf9,0x2e,0x0f,0x18,0xf3,0x67,0x3e,0x64,0x57,0xe0,0x42,0x3e,0x91,0xe0,0x40,0x04,
+  0x1e,0x02,0x0e,0x0c,0xf0,0x44,0xfe,0x90,0x20,0xfa,0x0d,0x20,0xf7,0x1d,0x20,0xf2,
+  0x0e,0x13,0x24,0x7c,0x1e,0x83,0xfe,0x62,0x28,0x06,0x1e,0xc1,0xfe,0x64,0x20,0x06,
+  0x7b,0xe2,0x0c,0x3e,0x87,0xe2,0xf0,0x42,0x90,0xe0,0x42,0x15,0x20,0xd2,0x05,0x20,
+  0x4f,0x16,0x20,0x18,0xcb,0x4f,0x06,0x04,0xc5,0xcb,0x11,0x17,0xc1,0xcb,0x11,0x17,
+  0x05,0x20,0xf5,0x22,0x23,0x22,0x23,0xc9,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,
+  0x21,0x04,0x01,0x11,0xa8,0x00,0x1a,0x13,0xbe,0x20,0xfe,0x23,0x7d,0xfe,0x34,0x20,
+  0xf5,0x06,0x19,0x78,0x86,0x23,0x05,0x20,0xfb,0x86,0x20,0xfe,0x3e,0x01,0xe0,0x50,
+};
+
+#endif

bsnes/gameboy/system/bootrom-sgb.cpp

@@ -0,0 +1,23 @@
+#ifdef SYSTEM_CPP
+
+//MD5SUM = d574d4f9c12f305074798f54c091a8b4
+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,
+  0x77,0x3e,0xfc,0xe0,0x47,0x21,0x5f,0xc0,0x0e,0x08,0xaf,0x32,0x0d,0x20,0xfc,0x11,
+  0x4f,0x01,0x3e,0xfb,0x0e,0x06,0xf5,0x06,0x00,0x1a,0x1b,0x32,0x80,0x47,0x0d,0x20,
+  0xf8,0x32,0xf1,0x32,0x0e,0x0e,0xd6,0x02,0xfe,0xef,0x20,0xea,0x11,0x04,0x01,0x21,
+  0x10,0x80,0x1a,0xcd,0xd3,0x00,0xcd,0xd4,0x00,0x13,0x7b,0xfe,0x34,0x20,0xf3,0x11,
+  0xe6,0x00,0x06,0x08,0x1a,0x13,0x22,0x23,0x05,0x20,0xf9,0x3e,0x19,0xea,0x10,0x99,
+  0x21,0x2f,0x99,0x0e,0x0c,0x3d,0x28,0x08,0x32,0x0d,0x20,0xf9,0x2e,0x0f,0x18,0xf3,
+  0x3e,0x91,0xe0,0x40,0x21,0x00,0xc0,0x0e,0x00,0x3e,0x00,0xe2,0x3e,0x30,0xe2,0x06,
+  0x10,0x1e,0x08,0x2a,0x57,0xcb,0x42,0x3e,0x10,0x20,0x02,0x3e,0x20,0xe2,0x3e,0x30,
+  0xe2,0xcb,0x1a,0x1d,0x20,0xef,0x05,0x20,0xe8,0x3e,0x20,0xe2,0x3e,0x30,0xe2,0xcd,
+  0xc2,0x00,0x7d,0xfe,0x60,0x20,0xd2,0x0e,0x13,0x3e,0xc1,0xe2,0x0c,0x3e,0x07,0xe2,
+  0x18,0x3a,0x16,0x04,0xf0,0x44,0xfe,0x90,0x20,0xfa,0x1e,0x00,0x1d,0x20,0xfd,0x15,
+  0x20,0xf2,0xc9,0x4f,0x06,0x04,0xc5,0xcb,0x11,0x17,0xc1,0xcb,0x11,0x17,0x05,0x20,
+  0xf5,0x22,0x23,0x22,0x23,0xc9,0x3c,0x42,0xb9,0xa5,0xb9,0xa5,0x42,0x3c,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x01,0xe0,0x50,
+};
+
+#endif

bsnes/gameboy/system/serialization.cpp

@@ -0,0 +1,63 @@
+#ifdef SYSTEM_CPP
+
+serializer System::serialize() {
+  serializer s(serialize_size);
+
+  unsigned signature = 0x31545342, version = Info::SerializerVersion, crc32 = 0;
+  char description[512];
+  memset(&description, 0, sizeof description);
+
+  s.integer(signature);
+  s.integer(version);
+  s.integer(crc32);
+  s.array(description);
+
+  serialize_all(s);
+  return s;
+}
+
+bool System::unserialize(serializer &s) {
+  unsigned signature, version, crc32;
+  char description[512];
+
+  s.integer(signature);
+  s.integer(version);
+  s.integer(crc32);
+  s.array(description);
+
+  if(signature != 0x31545342) return false;
+  if(version != Info::SerializerVersion) return false;
+//if(crc32 != 0) return false;
+
+  serialize_all(s);
+  return true;
+}
+
+void System::serialize(serializer &s) {
+  s.integer(clocks_executed);
+}
+
+void System::serialize_all(serializer &s) {
+  cartridge.serialize(s);
+  system.serialize(s);
+  cpu.serialize(s);
+  apu.serialize(s);
+  lcd.serialize(s);
+}
+
+void System::serialize_init() {
+  serializer s;
+
+  unsigned signature = 0, version = 0, crc32 = 0;
+  char description[512];
+
+  s.integer(signature);
+  s.integer(version);
+  s.integer(crc32);
+  s.array(description);
+
+  serialize_all(s);
+  serialize_size = s.size();
+}
+
+#endif

bsnes/gameboy/system/system.cpp

@@ -0,0 +1,68 @@
+#include <gameboy/gameboy.hpp>
+
+#define SYSTEM_CPP
+namespace GameBoy {
+
+#include "bootrom-dmg.cpp"
+#include "bootrom-sgb.cpp"
+#include "serialization.cpp"
+System system;
+
+void System::run() {
+  scheduler.sync = Scheduler::SynchronizeMode::None;
+
+  scheduler.enter();
+  if(scheduler.exit_reason() == Scheduler::ExitReason::FrameEvent) {
+  }
+}
+
+void System::runtosave() {
+  scheduler.sync = Scheduler::SynchronizeMode::CPU;
+  runthreadtosave();
+
+  scheduler.active_thread = lcd.thread;
+  runthreadtosave();
+}
+
+void System::runthreadtosave() {
+  while(true) {
+    scheduler.enter();
+    if(scheduler.exit_reason() == Scheduler::ExitReason::SynchronizeEvent) break;
+    if(scheduler.exit_reason() == Scheduler::ExitReason::FrameEvent) {
+    }
+  }
+}
+
+uint8 System::mmio_read(uint16 addr) {
+  if((addr & 0xff00) == 0x0000) {
+    return BootROM::sgb[addr];
+  }
+  return 0x00;
+}
+
+void System::mmio_write(uint16 addr, uint8 data) {
+  if(addr == 0xff50) {
+    if(data == 0x01) cartridge.map();
+  }
+}
+
+void System::init(Interface *interface_) {
+  interface = interface_;
+}
+
+void System::power() {
+  bus.power();
+  cartridge.power();
+  cpu.power();
+  apu.power();
+  lcd.power();
+  scheduler.init();
+
+  for(unsigned n = 0x0000; n <= 0x00ff; n++) bus.mmio[n] = this;
+  bus.mmio[0xff50] = this;
+
+  clocks_executed = 0;
+  serialize_init();
+}
+
+}

bsnes/gameboy/system/system.hpp

@@ -0,0 +1,39 @@
+class Interface;
+
+enum class Input : unsigned {
+  Up, Down, Left, Right, B, A, Select, Start,
+};
+
+struct System : MMIO {
+  struct BootROM {
+    static const uint8 dmg[256];
+    static const uint8 sgb[256];
+  } bootROM;
+
+  void run();
+  void runtosave();
+  void runthreadtosave();
+
+  uint8 mmio_read(uint16 addr);
+  void mmio_write(uint16 addr, uint8 data);
+
+  void init(Interface*);
+  void power();
+
+  Interface *interface;
+  unsigned clocks_executed;
+
+  //serialization.cpp
+  unsigned serialize_size;
+
+  serializer serialize();
+  bool unserialize(serializer&);
+
+  void serialize(serializer&);
+  void serialize_all(serializer&);
+  void serialize_init();
+};
+
+#include <gameboy/interface/interface.hpp>
+
+extern System system;

bsnes/launcher/bsnes.Manifest

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
-  <assemblyIdentity type="win32" name="bsnes" version="1.0.0.0" processorArchitecture="x86"/>
-  <dependency>
-    <dependentAssembly>
-      <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="X86" publicKeyToken="6595b64144ccf1df" language="*"/>
-    </dependentAssembly>
-  </dependency>
-</assembly>

bsnes/launcher/cc.bat

@@ -1,4 +0,0 @@
-@windres resource.rc resource.o
-@mingw32-g++ -std=gnu++0x -mwindows -s -O3 -fomit-frame-pointer -I.. -o ../out/bsnes launcher.cpp resource.o
-@del *.o
-@pause

bsnes/launcher/cc.sh

@@ -1,2 +0,0 @@
-clear
-g++ -std=gnu++0x -s -O3 -fomit-frame-pointer -I.. -o ../out/bsnes launcher.cpp

bsnes/launcher/launcher.cpp

@@ -1,54 +0,0 @@
-#include <nall/config.hpp>
-#include <nall/detect.hpp>
-#include <nall/file.hpp>
-#include <nall/foreach.hpp>
-#include <nall/platform.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-using namespace nall;
-
-int main(int argc, char **argv) {
-  char path[PATH_MAX], *unused;
-  #if !defined(PLATFORM_WIN)
-  unused = realpath(argv[0], path);
-  #else
-  wchar_t **argw = CommandLineToArgvW(GetCommandLineW(), &argc);
-  unused = realpath(nall::utf8_t(argw[0]), path);
-  #endif
-  string realPath = dir(path);
-  string basePath = string(dir(path), "bsnes-qt.cfg");
-  unused = userpath(path);
-  if(!strend(path, "/") && !strend(path, "\\")) strcat(path, "/");
-  string userPath = string(path, ".bsnes/bsnes-qt.cfg");
-
-  configuration config;
-  string profile;
-  config.attach(profile = "", "system.profile");
-  if(config.load(userPath) == false) config.load(basePath);
-  if(profile == "") profile = "compatibility";
-
-  string binaryName = string("bsnes-", profile);
-  #if defined(PLATFORM_WIN)
-  binaryName << ".dll";
-  #endif
-  string fileName = string(realPath, binaryName);
-
-  #if !defined(PLATFORM_WIN)
-  char **args = new char*[argc + 1];
-  args[0] = strdup(binaryName);
-  for(unsigned i = 1; i < argc; i++) args[i] = strdup(argv[i]);
-  args[argc] = 0;
-  execvp(args[0], args);
-  execv(fileName, args);
-  print("[bsnes] Error: unable to locate binary file: ", binaryName, "\n");
-  #else
-  STARTUPINFOW si;
-  PROCESS_INFORMATION pi;
-  memset(&si, 0, sizeof(STARTUPINFOW));
-  if(!CreateProcessW(nall::utf16_t(fileName), GetCommandLineW(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
-    MessageBoxA(0, string("Error: unable to locate binary file: ", binaryName), "bsnes", MB_OK);
-  }
-  #endif
-
-  return 0;
-}

bsnes/launcher/resource.rc

@@ -1,2 +0,0 @@
-1 24 "bsnes.Manifest"
-IDI_ICON1 ICON DISCARDABLE "bsnes.ico"

bsnes/nall/bit.hpp

@@ -3,12 +3,12 @@
 
 namespace nall {
   template<int bits> inline unsigned uclamp(const unsigned x) {
-    enum { y = (1U << bits) - 1 };
+    enum { y = (1U << (bits - 1)) + ((1U << (bits - 1)) - 1) };
     return y + ((x - y) & -(x < y));  //min(x, y);
   }
 
   template<int bits> inline unsigned uclip(const unsigned x) {
-    enum { m = (1U << bits) - 1 };
+    enum { m = (1U << (bits - 1)) + ((1U << (bits - 1)) - 1) };
     return (x & m);
   }
 

bsnes/nall/function.hpp

@@ -27,7 +27,7 @@ namespace nall {
     };
 
     template<typename L> struct lambda : container {
-      L object;
+      mutable L object;
       R operator()(P... p) const { return object(std::forward<P>(p)...); }
       container* copy() const { return new lambda(object); }
       lambda(const L& object) : object(object) {}
@@ -46,7 +46,7 @@ namespace nall {
       return *this;
     }
 
-    function(const function &source) { operator=(source); }
+    function(const function &source) : callback(0) { operator=(source); }
     function() : callback(0) {}
     function(void *function) : callback(0) { if(function) callback = new global((R (*)(P...))function); }
     function(R (*function)(P...)) { callback = new global(function); }

bsnes/nall/gameboy/cartridge.hpp

@@ -0,0 +1,105 @@
+#ifndef NALL_GAMEBOY_CARTRIDGE_HPP
+#define NALL_GAMEBOY_CARTRIDGE_HPP
+
+namespace nall {
+
+class GameBoyCartridge {
+public:
+  string xml;
+  inline GameBoyCartridge(const uint8_t *data, unsigned size);
+
+//private:
+  struct Information {
+    string mapper;
+    bool ram;
+    bool battery;
+    bool rtc;
+    bool rumble;
+
+    unsigned romsize;
+    unsigned ramsize;
+  } info;
+};
+
+GameBoyCartridge::GameBoyCartridge(const uint8_t *romdata, unsigned romsize) {
+  xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+  if(romsize < 0x4000) return;
+
+  info.mapper = "unknown";
+  info.ram = false;
+  info.battery = false;
+  info.rtc = false;
+  info.rumble = false;
+
+  info.romsize = 0;
+  info.ramsize = 0;
+
+  switch(romdata[0x0147]) {
+    case 0x00: info.mapper = "none";  break;
+    case 0x01: info.mapper = "MBC1";  break;
+    case 0x02: info.mapper = "MBC1";  info.ram = true; break;
+    case 0x03: info.mapper = "MBC1";  info.ram = true; info.battery = true; break;
+    case 0x05: info.mapper = "MBC2";  info.ram = true; break;
+    case 0x06: info.mapper = "MBC2";  info.ram = true; info.battery = true; break;
+    case 0x08: info.mapper = "none";  info.ram = true; break;
+    case 0x09: info.mapper = "MBC0";  info.ram = true; info.battery = true; break;
+    case 0x0b: info.mapper = "MMM01"; break;
+    case 0x0c: info.mapper = "MMM01"; info.ram = true; break;
+    case 0x0d: info.mapper = "MMM01"; info.ram = true; info.battery = true; break;
+    case 0x0f: info.mapper = "MBC3";  info.rtc = true; info.battery = true; break;
+    case 0x10: info.mapper = "MBC3";  info.rtc = true; info.ram = true; info.battery = true; break;
+    case 0x11: info.mapper = "MBC3";  break;
+    case 0x12: info.mapper = "MBC3";  info.ram = true; break;
+    case 0x13: info.mapper = "MBC3";  info.ram = true; info.battery = true; break;
+    case 0x19: info.mapper = "MBC5";  break;
+    case 0x1a: info.mapper = "MBC5";  info.ram = true; break;
+    case 0x1b: info.mapper = "MBC5";  info.ram = true; info.battery = true; break;
+    case 0x1c: info.mapper = "MBC5";  info.rumble = true; break;
+    case 0x1d: info.mapper = "MBC5";  info.rumble = true; info.ram = true; break;
+    case 0x1e: info.mapper = "MBC5";  info.rumble = true; info.ram = true; info.battery = true; break;
+    case 0xfc: break;  //Pocket Camera
+    case 0xfd: break;  //Bandai TAMA5
+    case 0xfe: info.mapper = "HuC3";  break;
+    case 0xff: info.mapper = "HuC1";  info.ram = true; info.battery = true; break;
+  }
+
+  switch(romdata[0x0148]) { default:
+    case 0x00: info.romsize =   2 * 16 * 1024; break;
+    case 0x01: info.romsize =   4 * 16 * 1024; break;
+    case 0x02: info.romsize =   8 * 16 * 1024; break;
+    case 0x03: info.romsize =  16 * 16 * 1024; break;
+    case 0x04: info.romsize =  32 * 16 * 1024; break;
+    case 0x05: info.romsize =  64 * 16 * 1024; break;
+    case 0x06: info.romsize = 128 * 16 * 1024; break;
+    case 0x07: info.romsize = 256 * 16 * 1024; break;
+    case 0x52: info.romsize =  72 * 16 * 1024; break;
+    case 0x53: info.romsize =  80 * 16 * 1024; break;
+    case 0x54: info.romsize =  96 * 16 * 1024; break;
+  }
+
+  switch(romdata[0x0149]) { default:
+    case 0x00: info.ramsize =  0 * 1024; break;
+    case 0x01: info.ramsize =  2 * 1024; break;
+    case 0x02: info.ramsize =  8 * 1024; break;
+    case 0x03: info.ramsize = 32 * 1024; break;
+  }
+
+  if(info.mapper == "MBC2") info.ramsize = 512;  //512 x 4-bit
+
+  xml << "<cartridge mapper='" << info.mapper << "'";
+  if(info.rtc) xml << " rtc='true'";
+  if(info.rumble) xml << " rumble='true'";
+  xml << ">\n";
+
+  xml << "  <rom size='" << hex(romsize) << "'/>\n";  //TODO: trust/check info.romsize?
+
+  if(info.ramsize > 0)
+  xml << "  <ram size='" << hex(info.ramsize) << "' battery='" << info.battery << "'/>\n";
+
+  xml << "</cartridge>\n";
+  xml.transform("'", "\"");
+}
+
+}
+
+#endif

bsnes/nall/snes/cartridge.hpp

@@ -112,13 +112,13 @@ SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
 
   if(type == TypeBsx) {
     xml << "<cartridge/>";
-    xmlMemoryMap = xml;
+    xmlMemoryMap = xml.transform("'", "\"");
     return;
   }
 
   if(type == TypeSufamiTurbo) {
     xml << "<cartridge/>";
-    xmlMemoryMap = xml;
+    xmlMemoryMap = xml.transform("'", "\"");
     return;
   }
 
@@ -128,7 +128,7 @@ SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
       xml << "  <ram size='" << hex(gameboy_ram_size(data, size)) << "'/>\n";
     }
     xml << "</cartridge>\n";
-    xmlMemoryMap = xml;
+    xmlMemoryMap = xml.transform("'", "\"");
     return;
   }
 
@@ -145,23 +145,19 @@ SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
     xml << "    <map mode='linear' address='00-7f:8000-ffff'/>\n";
     xml << "    <map mode='linear' address='80-ff:8000-ffff'/>\n";
     xml << "  </rom>\n";
-    xml << "  <supergameboy revision='1'>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:6000-7fff'/>\n";
-    xml << "      <map address='80-bf:6000-7fff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </supergameboy>\n";
+    xml << "  <icd2 revision='1'>\n";
+    xml << "    <map address='00-3f:6000-7fff'/>\n";
+    xml << "    <map address='80-bf:6000-7fff'/>\n";
+    xml << "  </icd2>\n";
   } else if(type == TypeSuperGameBoy2Bios) {
     xml << "  <rom>\n";
     xml << "    <map mode='linear' address='00-7f:8000-ffff'/>\n";
     xml << "    <map mode='linear' address='80-ff:8000-ffff'/>\n";
     xml << "  </rom>\n";
-    xml << "  <supergameboy revision='2'>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:6000-7fff'/>\n";
-    xml << "      <map address='80-bf:6000-7fff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </supergameboy>\n";
+    xml << "  <icd2 revision='2'>\n";
+    xml << "    <map address='00-3f:6000-7fff'/>\n";
+    xml << "    <map address='80-bf:6000-7fff'/>\n";
+    xml << "  </icd2>\n";
   } else if(has_spc7110) {
     xml << "  <rom>\n";
     xml << "    <map mode='shadow' address='00-0f:8000-ffff'/>\n";
@@ -283,19 +279,23 @@ SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
     xml << "  </superfx>\n";
   } else if(mapper == SA1ROM) {
     xml << "  <sa1>\n";
-    xml << "    <rom>\n";
-    xml << "      <map mode='linear' address='00-3f:8000-ffff'/>\n";
-    xml << "      <map mode='linear' address='80-bf:8000-ffff'/>\n";
-    xml << "      <map mode='linear' address='c0-ff:0000-ffff'/>\n";
-    xml << "    </rom>\n";
+    xml << "    <mcu>\n";
+    xml << "      <rom>\n";
+    xml << "        <map mode='direct' address='00-3f:8000-ffff'/>\n";
+    xml << "        <map mode='direct' address='80-bf:8000-ffff'/>\n";
+    xml << "        <map mode='direct' address='c0-ff:0000-ffff'/>\n";
+    xml << "      </rom>\n";
+    xml << "      <ram>\n";
+    xml << "        <map mode='direct' address='00-3f:6000-7fff'/>\n";
+    xml << "        <map mode='direct' address='80-bf:6000-7fff'/>\n";
+    xml << "      </ram>\n";
+    xml << "    </mcu>\n";
     xml << "    <iram size='800'>\n";
     xml << "      <map mode='linear' address='00-3f:3000-37ff'/>\n";
     xml << "      <map mode='linear' address='80-bf:3000-37ff'/>\n";
     xml << "    </iram>\n";
     xml << "    <bwram size='" << hex(ram_size) << "'>\n";
-    xml << "      <map mode='linear' address='00-3f:6000-7fff'/>\n";
     xml << "      <map mode='linear' address='40-4f:0000-ffff'/>\n";
-    xml << "      <map mode='linear' address='80-bf:6000-7fff'/>\n";
     xml << "    </bwram>\n";
     xml << "    <mmio>\n";
     xml << "      <map address='00-3f:2200-23ff'/>\n";
@@ -338,11 +338,14 @@ SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
     xml << "    </slot>\n";
     xml << "  </bsx>\n";
   } else if(mapper == BSXROM) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='linear' address='00-3f:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='80-bf:8000-ffff'/>\n";
-    xml << "  </rom>\n";
     xml << "  <bsx>\n";
+    xml << "    <mcu>\n";
+    xml << "      <map address='00-3f:8000-ffff'/>\n";
+    xml << "      <map address='80-bf:8000-ffff'/>\n";
+    xml << "      <map address='40-7f:0000-ffff'/>\n";
+    xml << "      <map address='c0-ff:0000-ffff'/>\n";
+    xml << "      <map address='20-3f:6000-7fff'/>\n";
+    xml << "    </mcu>\n";
     xml << "    <mmio>\n";
     xml << "      <map address='00-3f:5000-5fff'/>\n";
     xml << "      <map address='80-bf:5000-5fff'/>\n";
@@ -379,10 +382,8 @@ SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
 
   if(has_srtc) {
     xml << "  <srtc>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:2800-2801'/>\n";
-    xml << "      <map address='80-bf:2800-2801'/>\n";
-    xml << "    </mmio>\n";
+    xml << "    <map address='00-3f:2800-2801'/>\n";
+    xml << "    <map address='80-bf:2800-2801'/>\n";
     xml << "  </srtc>\n";
   }
 
@@ -400,15 +401,13 @@ SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
 
   if(has_cx4) {
     xml << "  <cx4>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:6000-7fff'/>\n";
-    xml << "      <map address='80-bf:6000-7fff'/>\n";
-    xml << "    </mmio>\n";
+    xml << "    <map address='00-3f:6000-7fff'/>\n";
+    xml << "    <map address='80-bf:6000-7fff'/>\n";
     xml << "  </cx4>\n";
   }
 
   if(has_dsp1) {
-    xml << "  <upd77c25 program='dsp1b.bin' sha256='4d42db0f36faef263d6b93f508e8c1c4ae8fc2605fd35e3390ecc02905cd420c'>\n";
+    xml << "  <necdsp revision='upd7725' frequency='8000000' program='dsp1b.bin' sha256='4d42db0f36faef263d6b93f508e8c1c4ae8fc2605fd35e3390ecc02905cd420c'>\n";
     if(dsp1_mapper == DSP1LoROM1MB) {
       xml << "    <dr>\n";
       xml << "      <map address='20-3f:8000-bfff'/>\n";
@@ -437,11 +436,11 @@ SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
       xml << "      <map address='80-9f:7000-7fff'/>\n";
       xml << "    </sr>\n";
     }
-    xml << "  </upd77c25>\n";
+    xml << "  </necdsp>\n";
   }
 
   if(has_dsp2) {
-    xml << "  <upd77c25 program='dsp2.bin' sha256='5efbdf96ed0652790855225964f3e90e6a4d466cfa64df25b110933c6cf94ea1'>\n";
+    xml << "  <necdsp revision='upd7725' frequency='8000000' program='dsp2.bin' sha256='5efbdf96ed0652790855225964f3e90e6a4d466cfa64df25b110933c6cf94ea1'>\n";
     xml << "    <dr>\n";
     xml << "      <map address='20-3f:8000-bfff'/>\n";
     xml << "      <map address='a0-bf:8000-bfff'/>\n";
@@ -450,11 +449,11 @@ SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
     xml << "      <map address='20-3f:c000-ffff'/>\n";
     xml << "      <map address='a0-bf:c000-ffff'/>\n";
     xml << "    </sr>\n";
-    xml << "  </upd77c25>\n";
+    xml << "  </necdsp>\n";
   }
 
   if(has_dsp3) {
-    xml << "  <upd77c25 program='dsp3.bin' sha256='2e635f72e4d4681148bc35429421c9b946e4f407590e74e31b93b8987b63ba90'>\n";
+    xml << "  <necdsp revision='upd7725' frequency='8000000' program='dsp3.bin' sha256='2e635f72e4d4681148bc35429421c9b946e4f407590e74e31b93b8987b63ba90'>\n";
     xml << "    <dr>\n";
     xml << "      <map address='20-3f:8000-bfff'/>\n";
     xml << "      <map address='a0-bf:8000-bfff'/>\n";
@@ -463,11 +462,11 @@ SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
     xml << "      <map address='20-3f:c000-ffff'/>\n";
     xml << "      <map address='a0-bf:c000-ffff'/>\n";
     xml << "    </sr>\n";
-    xml << "  </upd77c25>\n";
+    xml << "  </necdsp>\n";
   }
 
   if(has_dsp4) {
-    xml << "  <upd77c25 program='dsp4.bin' sha256='63ede17322541c191ed1fdf683872554a0a57306496afc43c59de7c01a6e764a'>\n";
+    xml << "  <necdsp revision='upd7725' frequency='8000000' program='dsp4.bin' sha256='63ede17322541c191ed1fdf683872554a0a57306496afc43c59de7c01a6e764a'>\n";
     xml << "    <dr>\n";
     xml << "      <map address='30-3f:8000-bfff'/>\n";
     xml << "      <map address='b0-bf:8000-bfff'/>\n";
@@ -476,48 +475,59 @@ SNESCartridge::SNESCartridge(const uint8_t *data, unsigned size) {
     xml << "      <map address='30-3f:c000-ffff'/>\n";
     xml << "      <map address='b0-bf:c000-ffff'/>\n";
     xml << "    </sr>\n";
-    xml << "  </upd77c25>\n";
+    xml << "  </necdsp>\n";
   }
 
   if(has_obc1) {
     xml << "  <obc1>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:6000-7fff'/>\n";
-    xml << "      <map address='80-bf:6000-7fff'/>\n";
-    xml << "    </mmio>\n";
+    xml << "    <map address='00-3f:6000-7fff'/>\n";
+    xml << "    <map address='80-bf:6000-7fff'/>\n";
     xml << "  </obc1>\n";
   }
 
   if(has_st010) {
-    xml << "  <setadsp program='ST-0010'>\n";
-    xml << "    <mmio>\n";
+    xml << "  <necdsp revision='upd96050' frequency='10000000' program='st0010.bin' sha256='55c697e864562445621cdf8a7bf6e84ae91361e393d382a3704e9aa55559041e'>\n";
+    xml << "    <dr>\n";
+    xml << "      <map address='60:0000'/>\n";
+    xml << "      <map address='e0:0000'/>\n";
+    xml << "    </dr>\n";
+    xml << "    <sr>\n";
+    xml << "      <map address='60:0001'/>\n";
+    xml << "      <map address='e0:0001'/>\n";
+    xml << "    </sr>\n";
+    xml << "    <dp>\n";
     xml << "      <map address='68-6f:0000-0fff'/>\n";
     xml << "      <map address='e8-ef:0000-0fff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </setadsp>\n";
+    xml << "    </dp>\n";
+    xml << "  </necdsp>\n";
   }
 
   if(has_st011) {
-    //ST-0011 addresses not verified; chip is unsupported
-    xml << "  <setadsp program='ST-0011'>\n";
-    xml << "    <mmio>\n";
+    xml << "  <necdsp revision='upd96050' frequency='15000000' program='st0011.bin' sha256='651b82a1e26c4fa8dd549e91e7f923012ed2ca54c1d9fd858655ab30679c2f0e'>\n";
+    xml << "    <dr>\n";
+    xml << "      <map address='60:0000'/>\n";
+    xml << "      <map address='e0:0000'/>\n";
+    xml << "    </dr>\n";
+    xml << "    <sr>\n";
+    xml << "      <map address='60:0001'/>\n";
+    xml << "      <map address='e0:0001'/>\n";
+    xml << "    </sr>\n";
+    xml << "    <dp>\n";
     xml << "      <map address='68-6f:0000-0fff'/>\n";
     xml << "      <map address='e8-ef:0000-0fff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </setadsp>\n";
+    xml << "    </dp>\n";
+    xml << "  </necdsp>\n";
   }
 
   if(has_st018) {
     xml << "  <setarisc program='ST-0018'>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:3800-38ff'/>\n";
-    xml << "      <map address='80-bf:3800-38ff'/>\n";
-    xml << "    </mmio>\n";
+    xml << "    <map address='00-3f:3800-38ff'/>\n";
+    xml << "    <map address='80-bf:3800-38ff'/>\n";
     xml << "  </setarisc>\n";
   }
 
   xml << "</cartridge>\n";
-  xmlMemoryMap = xml;
+  xmlMemoryMap = xml.transform("'", "\"");
 }
 
 void SNESCartridge::read_header(const uint8_t *data, unsigned size) {

bsnes/nall/string/base.hpp

@@ -145,10 +145,15 @@ namespace nall {
   inline unsigned strlcpy(string &dest, const char *src, unsigned length);
   inline unsigned strlcat(string &dest, const char *src, unsigned length);
   inline string substr(const char *src, unsigned start = 0, unsigned length = 0);
-  template<unsigned length = 0, char padding = '0'> inline string hex(uintmax_t value);
-  template<unsigned length = 0, char padding = '0'> inline string integer(intmax_t value);
-  template<unsigned length = 0, char padding = '0'> inline string decimal(uintmax_t value);
-  template<unsigned length = 0, char padding = '0'> inline string binary(uintmax_t value);
+
+  inline string integer(intmax_t value);
+  template<unsigned length = 0> inline string linteger(intmax_t value);
+  template<unsigned length = 0> inline string rinteger(intmax_t value);
+  inline string decimal(uintmax_t value);
+  template<unsigned length = 0> inline string ldecimal(uintmax_t value);
+  template<unsigned length = 0> inline string rdecimal(uintmax_t value);
+  template<unsigned length = 0> inline string hex(uintmax_t value);
+  template<unsigned length = 0> inline string binary(uintmax_t value);
   inline unsigned fp(char *str, double value);
   inline string fp(double value);
 

bsnes/nall/string/utility.hpp

@@ -27,7 +27,151 @@ string substr(const char *src, unsigned start, unsigned length) {
 
 /* arithmetic <> string */
 
-template<unsigned length, char padding> string hex(uintmax_t value) {
+string integer(intmax_t value) {
+  bool negative = value < 0;
+  if(negative) value = abs(value);
+
+  char buffer[64];
+  unsigned size = 0;
+
+  do {
+    unsigned n = value % 10;
+    buffer[size++] = '0' + n;
+    value /= 10;
+  } while(value);
+  buffer[size++] = negative ? '-' : '+';
+  buffer[size] = 0;
+
+  char result[size + 1];
+  memset(result, '0', size);
+  result[size] = 0;
+
+  for(signed x = size - 1, y = 0; x >= 0 && y < size; x--, y++) {
+    result[x] = buffer[y];
+  }
+
+  return result;
+}
+
+template<unsigned length> string linteger(intmax_t value) {
+  bool negative = value < 0;
+  if(negative) value = abs(value);
+
+  char buffer[64];
+  unsigned size = 0;
+
+  do {
+    unsigned n = value % 10;
+    buffer[size++] = '0' + n;
+    value /= 10;
+  } while(value);
+  buffer[size++] = negative ? '-' : '+';
+  buffer[size] = 0;
+
+  char result[length + 1];
+  memset(result, ' ', length);
+  result[length] = 0;
+
+  for(signed x = 0, y = size - 1; x < length && y >= 0; x++, y--) {
+    result[x] = buffer[y];
+  }
+
+  return result;
+}
+
+template<unsigned length> string rinteger(intmax_t value) {
+  bool negative = value < 0;
+  if(negative) value = abs(value);
+
+  char buffer[64];
+  unsigned size = 0;
+
+  do {
+    unsigned n = value % 10;
+    buffer[size++] = '0' + n;
+    value /= 10;
+  } while(value);
+  buffer[size++] = negative ? '-' : '+';
+  buffer[size] = 0;
+
+  char result[length + 1];
+  memset(result, ' ', length);
+  result[length] = 0;
+
+  for(signed x = length - 1, y = 0; x >= 0 && y < size; x--, y++) {
+    result[x] = buffer[y];
+  }
+
+  return result;
+}
+
+string decimal(uintmax_t value) {
+  char buffer[64];
+  unsigned size = 0;
+
+  do {
+    unsigned n = value % 10;
+    buffer[size++] = '0' + n;
+    value /= 10;
+  } while(value);
+  buffer[size] = 0;
+
+  char result[size + 1];
+  memset(result, '0', size);
+  result[size] = 0;
+
+  for(signed x = size - 1, y = 0; x >= 0 && y < size; x--, y++) {
+    result[x] = buffer[y];
+  }
+
+  return result;
+}
+
+template<unsigned length> string ldecimal(uintmax_t value) {
+  char buffer[64];
+  unsigned size = 0;
+
+  do {
+    unsigned n = value % 10;
+    buffer[size++] = '0' + n;
+    value /= 10;
+  } while(value);
+  buffer[size] = 0;
+
+  char result[length + 1];
+  memset(result, ' ', length);
+  result[length] = 0;
+
+  for(signed x = 0, y = size - 1; x < length && y >= 0; x++, y--) {
+    result[x] = buffer[y];
+  }
+
+  return result;
+}
+
+template<unsigned length> string rdecimal(uintmax_t value) {
+  char buffer[64];
+  unsigned size = 0;
+
+  do {
+    unsigned n = value % 10;
+    buffer[size++] = '0' + n;
+    value /= 10;
+  } while(value);
+  buffer[size] = 0;
+
+  char result[length + 1];
+  memset(result, ' ', length);
+  result[length] = 0;
+
+  for(signed x = length - 1, y = 0; x >= 0 && y < size; x--, y++) {
+    result[x] = buffer[y];
+  }
+
+  return result;
+}
+
+template<unsigned length> string hex(uintmax_t value) {
   string output;
   unsigned offset = 0;
 
@@ -38,7 +182,7 @@ template<unsigned length, char padding> string hex(uintmax_t value) {
     value >>= 4;
   } while(value);
 
-  while(offset < length) output[offset++] = padding;
+  while(offset < length) output[offset++] = '0';
   output[offset--] = 0;
 
   //reverse the string in-place
@@ -51,55 +195,7 @@ template<unsigned length, char padding> string hex(uintmax_t value) {
   return output;
 }
 
-template<unsigned length, char padding> string integer(intmax_t value) {
-  string output;
-  unsigned offset = 0;
-
-  bool negative = value < 0;
-  if(negative) value = abs(value);
-
-  do {
-    unsigned n = value % 10;
-    output[offset++] = '0' + n;
-    value /= 10;
-  } while(value);
-
-  while(offset < length) output[offset++] = padding;
-  if(negative) output[offset++] = '-';
-  output[offset--] = 0;
-
-  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
-    char temp = output[i];
-    output[i] = output[offset - i];
-    output[offset - i] = temp;
-  }
-
-  return output;
-}
-
-template<unsigned length, char padding> string decimal(uintmax_t value) {
-  string output;
-  unsigned offset = 0;
-
-  do {
-    unsigned n = value % 10;
-    output[offset++] = '0' + n;
-    value /= 10;
-  } while(value);
-
-  while(offset < length) output[offset++] = padding;
-  output[offset--] = 0;
-
-  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
-    char temp = output[i];
-    output[i] = output[offset - i];
-    output[offset - i] = temp;
-  }
-
-  return output;
-}
-
-template<unsigned length, char padding> string binary(uintmax_t value) {
+template<unsigned length> string binary(uintmax_t value) {
   string output;
   unsigned offset = 0;
 
@@ -109,7 +205,7 @@ template<unsigned length, char padding> string binary(uintmax_t value) {
     value >>= 1;
   } while(value);
 
-  while(offset < length) output[offset++] = padding;
+  while(offset < length) output[offset++] = '0';
   output[offset--] = 0;
 
   for(unsigned i = 0; i < (offset + 1) >> 1; i++) {

bsnes/nall/varint.hpp

@@ -8,84 +8,110 @@
 namespace nall {
   template<unsigned bits> class uint_t {
   private:
-    enum { bytes = (bits + 7) >> 3 };  //minimum number of bytes needed to store value
-    typedef typename static_if<
-      sizeof(int) >= bytes,
-      unsigned int,
-      typename static_if<
-        sizeof(long) >= bytes,
-        unsigned long,
-        typename static_if<
-          sizeof(long long) >= bytes,
-          unsigned long long,
-          void
-        >::type
-      >::type
-    >::type T;
-    static_assert(!std::is_same<T, void>::value, "");
-    T data;
+    unsigned data;
 
   public:
-    inline operator T() const { return data; }
-    inline T operator ++(int) { T r = data; data = uclip<bits>(data + 1); return r; }
-    inline T operator --(int) { T r = data; data = uclip<bits>(data - 1); return r; }
-    inline T operator ++() { return data = uclip<bits>(data + 1); }
-    inline T operator --() { return data = uclip<bits>(data - 1); }
-    inline T operator  =(const T i) { return data = uclip<bits>(i); }
-    inline T operator |=(const T i) { return data = uclip<bits>(data  | i); }
-    inline T operator ^=(const T i) { return data = uclip<bits>(data  ^ i); }
-    inline T operator &=(const T i) { return data = uclip<bits>(data  & i); }
-    inline T operator<<=(const T i) { return data = uclip<bits>(data << i); }
-    inline T operator>>=(const T i) { return data = uclip<bits>(data >> i); }
-    inline T operator +=(const T i) { return data = uclip<bits>(data  + i); }
-    inline T operator -=(const T i) { return data = uclip<bits>(data  - i); }
-    inline T operator *=(const T i) { return data = uclip<bits>(data  * i); }
-    inline T operator /=(const T i) { return data = uclip<bits>(data  / i); }
-    inline T operator %=(const T i) { return data = uclip<bits>(data  % i); }
+    inline operator unsigned() const { return data; }
+    inline unsigned operator ++(int) { unsigned r = data; data = uclip<bits>(data + 1); return r; }
+    inline unsigned operator --(int) { unsigned r = data; data = uclip<bits>(data - 1); return r; }
+    inline unsigned operator ++() { return data = uclip<bits>(data + 1); }
+    inline unsigned operator --() { return data = uclip<bits>(data - 1); }
+    inline unsigned operator  =(const unsigned i) { return data = uclip<bits>(i); }
+    inline unsigned operator |=(const unsigned i) { return data = uclip<bits>(data  | i); }
+    inline unsigned operator ^=(const unsigned i) { return data = uclip<bits>(data  ^ i); }
+    inline unsigned operator &=(const unsigned i) { return data = uclip<bits>(data  & i); }
+    inline unsigned operator<<=(const unsigned i) { return data = uclip<bits>(data << i); }
+    inline unsigned operator>>=(const unsigned i) { return data = uclip<bits>(data >> i); }
+    inline unsigned operator +=(const unsigned i) { return data = uclip<bits>(data  + i); }
+    inline unsigned operator -=(const unsigned i) { return data = uclip<bits>(data  - i); }
+    inline unsigned operator *=(const unsigned i) { return data = uclip<bits>(data  * i); }
+    inline unsigned operator /=(const unsigned i) { return data = uclip<bits>(data  / i); }
+    inline unsigned operator %=(const unsigned i) { return data = uclip<bits>(data  % i); }
 
     inline uint_t() : data(0) {}
-    inline uint_t(const T i) : data(uclip<bits>(i)) {}
+    inline uint_t(const unsigned i) : data(uclip<bits>(i)) {}
   };
 
   template<unsigned bits> class int_t {
   private:
-    enum { bytes = (bits + 7) >> 3 };  //minimum number of bytes needed to store value
-    typedef typename static_if<
-      sizeof(int) >= bytes,
-      signed int,
-      typename static_if<
-        sizeof(long) >= bytes,
-        signed long,
-        typename static_if<
-          sizeof(long long) >= bytes,
-          signed long long,
-          void
-        >::type
-      >::type
-    >::type T;
-    static_assert(!std::is_same<T, void>::value, "");
-    T data;
+    signed data;
 
   public:
-    inline operator T() const { return data; }
-    inline T operator ++(int) { T r = data; data = sclip<bits>(data + 1); return r; }
-    inline T operator --(int) { T r = data; data = sclip<bits>(data - 1); return r; }
-    inline T operator ++() { return data = sclip<bits>(data + 1); }
-    inline T operator --() { return data = sclip<bits>(data - 1); }
-    inline T operator  =(const T i) { return data = sclip<bits>(i); }
-    inline T operator |=(const T i) { return data = sclip<bits>(data  | i); }
-    inline T operator ^=(const T i) { return data = sclip<bits>(data  ^ i); }
-    inline T operator &=(const T i) { return data = sclip<bits>(data  & i); }
-    inline T operator<<=(const T i) { return data = sclip<bits>(data << i); }
-    inline T operator>>=(const T i) { return data = sclip<bits>(data >> i); }
-    inline T operator +=(const T i) { return data = sclip<bits>(data  + i); }
-    inline T operator -=(const T i) { return data = sclip<bits>(data  - i); }
-    inline T operator *=(const T i) { return data = sclip<bits>(data  * i); }
-    inline T operator /=(const T i) { return data = sclip<bits>(data  / i); }
-    inline T operator %=(const T i) { return data = sclip<bits>(data  % i); }
+    inline operator signed() const { return data; }
+    inline signed operator ++(int) { signed r = data; data = sclip<bits>(data + 1); return r; }
+    inline signed operator --(int) { signed r = data; data = sclip<bits>(data - 1); return r; }
+    inline signed operator ++() { return data = sclip<bits>(data + 1); }
+    inline signed operator --() { return data = sclip<bits>(data - 1); }
+    inline signed operator  =(const signed i) { return data = sclip<bits>(i); }
+    inline signed operator |=(const signed i) { return data = sclip<bits>(data  | i); }
+    inline signed operator ^=(const signed i) { return data = sclip<bits>(data  ^ i); }
+    inline signed operator &=(const signed i) { return data = sclip<bits>(data  & i); }
+    inline signed operator<<=(const signed i) { return data = sclip<bits>(data << i); }
+    inline signed operator>>=(const signed i) { return data = sclip<bits>(data >> i); }
+    inline signed operator +=(const signed i) { return data = sclip<bits>(data  + i); }
+    inline signed operator -=(const signed i) { return data = sclip<bits>(data  - i); }
+    inline signed operator *=(const signed i) { return data = sclip<bits>(data  * i); }
+    inline signed operator /=(const signed i) { return data = sclip<bits>(data  / i); }
+    inline signed operator %=(const signed i) { return data = sclip<bits>(data  % i); }
 
     inline int_t() : data(0) {}
-    inline int_t(const T i) : data(sclip<bits>(i)) {}
+    inline int_t(const signed i) : data(sclip<bits>(i)) {}
+  };
+
+  class varuint_t {
+  private:
+    unsigned data;
+    unsigned mask;
+
+  public:
+    inline operator unsigned() const { return data; }
+    inline unsigned operator ++(int) { unsigned r = data; data = (data + 1) & mask; return r; }
+    inline unsigned operator --(int) { unsigned r = data; data = (data - 1) & mask; return r; }
+    inline unsigned operator ++() { return data = (data + 1) & mask; }
+    inline unsigned operator --() { return data = (data - 1) & mask; }
+    inline unsigned operator  =(const unsigned i) { return data = (i) & mask; }
+    inline unsigned operator |=(const unsigned i) { return data = (data  | i) & mask; }
+    inline unsigned operator ^=(const unsigned i) { return data = (data  ^ i) & mask; }
+    inline unsigned operator &=(const unsigned i) { return data = (data  & i) & mask; }
+    inline unsigned operator<<=(const unsigned i) { return data = (data << i) & mask; }
+    inline unsigned operator>>=(const unsigned i) { return data = (data >> i) & mask; }
+    inline unsigned operator +=(const unsigned i) { return data = (data  + i) & mask; }
+    inline unsigned operator -=(const unsigned i) { return data = (data  - i) & mask; }
+    inline unsigned operator *=(const unsigned i) { return data = (data  * i) & mask; }
+    inline unsigned operator /=(const unsigned i) { return data = (data  / i) & mask; }
+    inline unsigned operator %=(const unsigned i) { return data = (data  % i) & mask; }
+
+    inline void bits(unsigned bits) { mask = (1U << (bits - 1)) + ((1U << (bits - 1)) - 1); data &= mask; }
+    inline varuint_t() : data(0), mask(~0U) {}
+    inline varuint_t(const unsigned i) : data(i), mask(~0U) {}
+  };
+
+  class varuintmax_t {
+  private:
+    uintmax_t data;
+    uintmax_t mask;
+
+  public:
+    inline operator uintmax_t() const { return data; }
+    inline uintmax_t operator ++(int) { uintmax_t r = data; data = (data + 1) & mask; return r; }
+    inline uintmax_t operator --(int) { uintmax_t r = data; data = (data - 1) & mask; return r; }
+    inline uintmax_t operator ++() { return data = (data + 1) & mask; }
+    inline uintmax_t operator --() { return data = (data - 1) & mask; }
+    inline uintmax_t operator  =(const uintmax_t i) { return data = (i) & mask; }
+    inline uintmax_t operator |=(const uintmax_t i) { return data = (data  | i) & mask; }
+    inline uintmax_t operator ^=(const uintmax_t i) { return data = (data  ^ i) & mask; }
+    inline uintmax_t operator &=(const uintmax_t i) { return data = (data  & i) & mask; }
+    inline uintmax_t operator<<=(const uintmax_t i) { return data = (data << i) & mask; }
+    inline uintmax_t operator>>=(const uintmax_t i) { return data = (data >> i) & mask; }
+    inline uintmax_t operator +=(const uintmax_t i) { return data = (data  + i) & mask; }
+    inline uintmax_t operator -=(const uintmax_t i) { return data = (data  - i) & mask; }
+    inline uintmax_t operator *=(const uintmax_t i) { return data = (data  * i) & mask; }
+    inline uintmax_t operator /=(const uintmax_t i) { return data = (data  / i) & mask; }
+    inline uintmax_t operator %=(const uintmax_t i) { return data = (data  % i) & mask; }
+
+    inline void bits(unsigned bits) { mask = (1ULL << (bits - 1)) + ((1ULL << (bits - 1)) - 1); data &= mask; }
+    inline varuintmax_t() : data(0), mask(~0ULL) {}
+    inline varuintmax_t(const uintmax_t i) : data(i), mask(~0ULL) {}
   };
 }
 

bsnes/nall/vector.hpp

@@ -46,7 +46,7 @@ namespace nall {
     void reserve(unsigned newsize) {
       newsize = bit::round(newsize);  //round to nearest power of two (for amortized growth)
 
-      T *poolcopy = (T*)malloc(newsize * sizeof(T));
+      T *poolcopy = (T*)calloc(newsize, sizeof(T));
       for(unsigned i = 0; i < min(objectsize, newsize); i++) new(poolcopy + i) T(pool[i]);
       for(unsigned i = 0; i < objectsize; i++) pool[i].~T();
       free(pool);

bsnes/phoenix/gtk/gtk.hpp

@@ -107,6 +107,8 @@ struct Window : Widget {
   void setStatusText(const nall::string &text);
   void setMenuVisible(bool visible = true);
   void setStatusVisible(bool visible = true);
+  bool fullscreen();
+  void setFullscreen(bool fullscreen = true);
   Window();
 //private:
   struct Data;

bsnes/phoenix/gtk/object.cpp

@@ -27,6 +27,11 @@ struct Widget::Data {
 
 struct Window::Data {
   Font *defaultFont;
+  bool isFullscreen;
+  unsigned x;
+  unsigned y;
+  unsigned width;
+  unsigned height;
 };
 
 struct Canvas::Data {

bsnes/phoenix/gtk/window.cpp

@@ -8,6 +8,11 @@ static gint Window_close(Window *window) {
 }
 
 void Window::create(unsigned x, unsigned y, unsigned width, unsigned height, const string &text) {
+  window->x = x;
+  window->y = y;
+  window->width = width;
+  window->height = height;
+
   object->widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_move(GTK_WINDOW(object->widget), x, y);
 
@@ -55,8 +60,8 @@ Geometry Window::geometry() {
 }
 
 void Window::setGeometry(unsigned x, unsigned y, unsigned width, unsigned height) {
-  gtk_window_move(GTK_WINDOW(object->widget), x, y);
-  gtk_widget_set_size_request(object->formContainer, width, height);
+  gtk_window_move(GTK_WINDOW(object->widget), window->x = x, window->y = y);
+  gtk_widget_set_size_request(object->formContainer, window->width = width, window->height = height);
 }
 
 void Window::setDefaultFont(Font &font) {
@@ -93,7 +98,40 @@ void Window::setStatusVisible(bool visible) {
   gtk_widget_set_visible(object->status, visible);
 }
 
+bool Window::fullscreen() {
+  return window->isFullscreen;
+}
+
+void Window::setFullscreen(bool fullscreen) {
+  window->isFullscreen = fullscreen;
+  if(fullscreen == true) {
+    gtk_window_fullscreen(GTK_WINDOW(object->widget));
+    gtk_window_set_decorated(GTK_WINDOW(object->widget), false);
+    gtk_widget_set_size_request(object->widget, gdk_screen_width(), gdk_screen_height());
+  } else {
+    gtk_widget_set_size_request(object->widget, -1, -1);
+    gtk_window_set_decorated(GTK_WINDOW(object->widget), true);
+    gtk_window_unfullscreen(GTK_WINDOW(object->widget));
+
+    //at this point, GTK+ has not updated window geometry
+    //this causes Window::geometry() calls to return incorrect info
+    //thus, wait until the geometry has changed before continuing
+    Geometry geom;
+    time_t startTime = time(0);
+    do {
+      OS::run();
+      Geometry geom = geometry();
+      if(startTime - time(0) > 3) break;  //prevent application from freezing
+    } while(geom.x == 0 && geom.y == 0 && geom.width == gdk_screen_width() && geom.height == gdk_screen_height());
+  }
+}
+
 Window::Window() {
   window = new Window::Data;
   window->defaultFont = 0;
+  window->isFullscreen = false;
+  window->x = 0;
+  window->y = 0;
+  window->width = 0;
+  window->height = 0;
 }

bsnes/phoenix/qt/qt.hpp

@@ -140,6 +140,8 @@ struct Window : Widget {
   void setMenuVisible(bool visible = true);
   void setStatusVisible(bool visible = true);
   bool focused();
+  bool fullscreen();
+  void setFullscreen(bool fullscreen = true);
   Window();
 //private:
   struct Data;

bsnes/phoenix/qt/qt.moc

@@ -1,7 +1,7 @@
 /****************************************************************************
 ** Meta object code from reading C++ file 'qt.moc.hpp'
 **
-** Created: Mon Nov 1 06:26:59 2010
+** Created: Tue Jan 18 03:30:57 2011
 **      by: The Qt Meta Object Compiler version 62 (Qt 4.6.2)
 **
 ** WARNING! All changes made in this file will be lost!

bsnes/phoenix/qt/window.cpp

@@ -3,6 +3,7 @@ void Window::create(unsigned x, unsigned y, unsigned width, unsigned height, con
   window->move(x, y);
 
   window->layout = new QVBoxLayout(window);
+  window->layout->setAlignment(Qt::AlignTop);
   window->layout->setMargin(0);
   window->layout->setSpacing(0);
   window->layout->setSizeConstraint(QLayout::SetFixedSize);
@@ -70,6 +71,28 @@ bool Window::focused() {
   return window->isActiveWindow() && !window->isMinimized();
 }
 
+bool Window::fullscreen() {
+  return window->isFullScreen();
+}
+
+void Window::setFullscreen(bool fullscreen) {
+  if(fullscreen == false) {
+    window->showNormal();
+  } else {
+    window->showFullScreen();
+  }
+
+  //Qt returns negative coordinates for x,y immediately after setFullscreen(false)
+  //wait for Qt to return sane values, or until timeout occurs
+  Geometry geom;
+  time_t startTime = time(0);
+  do {
+    OS::run();
+    geom = geometry();
+    if(startTime - time(0) > 3) break;
+  } while((signed)geom.x < 0 || (signed)geom.y < 0);
+}
+
 Window::Window() {
   window = new Window::Data(*this);
   window->defaultFont = 0;

bsnes/phoenix/windows/object.cpp

@@ -26,6 +26,9 @@ struct Window::Data {
   COLORREF brushColor;
   HMENU menu;
   HWND status;
+  bool isFullscreen;
+  unsigned x;
+  unsigned y;
   unsigned width;
   unsigned height;
 };

bsnes/phoenix/windows/window.cpp

@@ -2,7 +2,7 @@ void Window::create(unsigned x, unsigned y, unsigned width, unsigned height, con
   widget->window = CreateWindowEx(
     0, L"phoenix_window", utf16_t(text),
     WS_POPUP | WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX,
-    x, y, width, height,
+    window->x = x, window->y = y, window->width = width, window->height = height,
     0, 0, GetModuleHandle(0), 0
   );
   window->menu = CreateMenu();
@@ -39,6 +39,13 @@ Geometry Window::geometry() {
 }
 
 void Window::setGeometry(unsigned x, unsigned y, unsigned width, unsigned height) {
+  if(window->isFullscreen == false) {
+    window->x = x;
+    window->y = y;
+    window->width = width;
+    window->height = height;
+  }
+
   bool isVisible = visible();
   if(isVisible) setVisible(false);
   SetWindowPos(widget->window, NULL, x, y, width, height, SWP_NOZORDER | SWP_FRAMECHANGED);
@@ -70,16 +77,33 @@ void Window::setStatusVisible(bool visible) {
   resize(window->width, window->height);
 }
 
+bool Window::fullscreen() {
+  return window->isFullscreen;
+}
+
+void Window::setFullscreen(bool fullscreen) {
+  window->isFullscreen = fullscreen;
+  if(fullscreen == false) {
+    SetWindowLong(widget->window, GWL_STYLE, WS_VISIBLE | WS_POPUP | WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX);
+    setGeometry(window->x, window->y, window->width, window->height);
+  } else {
+    SetWindowLong(widget->window, GWL_STYLE, WS_VISIBLE | WS_POPUP);
+    setGeometry(0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
+  }
+}
+
 Window::Window() {
   window = new Window::Data;
   window->defaultFont = 0;
   window->brush = 0;
+  window->isFullscreen = false;
+  window->x = 0;
+  window->y = 0;
+  window->width = 0;
+  window->height = 0;
 }
 
 void Window::resize(unsigned width, unsigned height) {
-  window->width = width;
-  window->height = height;
-
   SetWindowPos(widget->window, NULL, 0, 0, width, height, SWP_NOZORDER | SWP_NOMOVE | SWP_FRAMECHANGED);
   RECT rc;
   GetClientRect(widget->window, &rc);

bsnes/phoenix/windows/windows.hpp

@@ -112,6 +112,8 @@ struct Window : Widget {
   void setStatusText(const nall::string &text);
   void setMenuVisible(bool visible = true);
   void setStatusVisible(bool visible = true);
+  bool fullscreen();
+  void setFullscreen(bool fullscreen = true);
   Window();
 //private:
   struct Data;

bsnes/snes/Makefile

@@ -1,11 +1,10 @@
-snes_objects := libco
-snes_objects += snes-system
+snes_objects := snes-system
 snes_objects += snes-cartridge snes-cheat
 snes_objects += snes-memory snes-cpucore snes-smpcore
 snes_objects += snes-cpu snes-smp snes-dsp snes-ppu
-snes_objects += snes-supergameboy snes-superfx snes-sa1 snes-upd77c25
+snes_objects += snes-icd2 snes-superfx snes-sa1 snes-necdsp
 snes_objects += snes-bsx snes-srtc snes-sdd1 snes-spc7110 snes-cx4
-snes_objects += snes-obc1 snes-st0010 snes-st0011 snes-st0018
+snes_objects += snes-obc1 snes-st0018 snes-sufamiturbo
 snes_objects += snes-msu1 snes-serial
 objects += $(snes_objects)
 
@@ -29,9 +28,6 @@ else ifeq ($(profile),performance)
   snesppu := $(snes)/alt/ppu-performance
 endif
 
-obj/libco.o  : libco/libco.c libco/*
-obj/libsnes.o: $(snes)/libsnes/libsnes.cpp $(snes)/libsnes/*
-
 obj/snes-system.o   : $(snes)/system/system.cpp $(call rwildcard,$(snes)/system/) $(call rwildcard,$(snes)/video/)
 obj/snes-memory.o   : $(snes)/memory/memory.cpp $(call rwildcard,$(snes)/memory/)
 obj/snes-cpucore.o  : $(snes)/cpu/core/core.cpp $(call rwildcard,$(snes)/cpu/core/)
@@ -40,55 +36,20 @@ obj/snes-cpu.o      : $(snescpu)/cpu.cpp $(call rwildcard,$(snescpu)/)
 obj/snes-smp.o      : $(snessmp)/smp.cpp $(call rwildcard,$(snessmp)/)
 obj/snes-dsp.o      : $(snesdsp)/dsp.cpp $(call rwildcard,$(snesdsp)/)
 obj/snes-ppu.o      : $(snesppu)/ppu.cpp $(call rwildcard,$(snesppu)/)
-obj/snes-cartridge.o: $(snes)/cartridge/cartridge.cpp $(call rwilddcard,$(snes)/cartridge/)
-obj/snes-cheat.o    : $(snes)/cheat/cheat.cpp $(call rwildcard,$(snes)/cheat/)
+obj/snes-cartridge.o: $(snes)/cartridge/cartridge.cpp $(snes)/cartridge/*
+obj/snes-cheat.o    : $(snes)/cheat/cheat.cpp $(snes)/cheat/*
 
-obj/snes-supergameboy.o: $(snes)/chip/supergameboy/supergameboy.cpp $(call rwildcard,$(snes)/chip/supergameboy/)
-obj/snes-superfx.o     : $(snes)/chip/superfx/superfx.cpp $(call rwildcard,$(snes)/chip/superfx/)
-obj/snes-sa1.o         : $(snes)/chip/sa1/sa1.cpp $(call rwildcard,$(snes)/chip/sa1/)
-obj/snes-upd77c25.o    : $(snes)/chip/upd77c25/upd77c25.cpp $(call rwildcard,$(snes)/chip/upd77c25/)
-obj/snes-bsx.o         : $(snes)/chip/bsx/bsx.cpp $(snes)/chip/bsx/*
-obj/snes-srtc.o        : $(snes)/chip/srtc/srtc.cpp $(snes)/chip/srtc/*
-obj/snes-sdd1.o        : $(snes)/chip/sdd1/sdd1.cpp $(snes)/chip/sdd1/*
-obj/snes-spc7110.o     : $(snes)/chip/spc7110/spc7110.cpp $(snes)/chip/spc7110/*
-obj/snes-cx4.o         : $(snes)/chip/cx4/cx4.cpp $(snes)/chip/cx4/*
-obj/snes-obc1.o        : $(snes)/chip/obc1/obc1.cpp $(snes)/chip/obc1/*
-obj/snes-st0010.o      : $(snes)/chip/st0010/st0010.cpp $(snes)/chip/st0010/*
-obj/snes-st0011.o      : $(snes)/chip/st0011/st0011.cpp $(snes)/chip/st0011/*
-obj/snes-st0018.o      : $(snes)/chip/st0018/st0018.cpp $(snes)/chip/st0018/*
-obj/snes-msu1.o        : $(snes)/chip/msu1/msu1.cpp $(snes)/chip/msu1/*
-obj/snes-serial.o      : $(snes)/chip/serial/serial.cpp $(snes)/chip/serial/*
-
-###########
-# library #
-###########
-
-snes_objects := $(patsubst %,obj/%.o,$(snes_objects))
-
-library: $(snes_objects) obj/libsnes.o
-ifeq ($(platform),x)
-	ar rcs out/libsnes.a $(snes_objects) obj/libsnes.o
-	$(cpp) -o out/libsnes.so -shared -Wl,-soname,libsnes.so.1 $(snes_objects) obj/libsnes.o
-else ifeq ($(platform),osx)
-	ar rcs out/libsnes.a $(snes_objects) obj/libsnes.o
-	$(cpp) -o out/libsnes.dylib -install_name @executable_path/../Libraries/libsnes.dylib -shared -dynamiclib $(snes_objects) obj/libsnes.o
-else ifeq ($(platform),win)
-	$(cpp) -o out/snes.dll -shared -Wl,--out-implib,libsnes.a $(snes_objects) obj/libsnes.o
-endif
-
-library-install:
-ifeq ($(platform),x)
-	install -D -m 755 out/libsnes.a $(DESTDIR)$(prefix)/lib/libsnes.a
-	install -D -m 755 out/libsnes.so $(DESTDIR)$(prefix)/lib/libsnes.so
-	ldconfig -n $(DESTDIR)$(prefix)/lib
-else ifeq ($(platform),osx)
-	cp out/libsnes.dylib /usr/local/lib/libsnes.dylib
-endif
-
-library-uninstall:
-ifeq ($(platform),x)
-	rm $(DESTDIR)$(prefix)/lib/libsnes.a
-	rm $(DESTDIR)$(prefix)/lib/libsnes.so
-else ifeq ($(platform),osx)
-	rm /usr/local/lib/libsnes.dylib
-endif
+obj/snes-icd2.o       : $(snes)/chip/icd2/icd2.cpp $(call rwildcard,$(snes)/chip/icd2/)
+obj/snes-superfx.o    : $(snes)/chip/superfx/superfx.cpp $(call rwildcard,$(snes)/chip/superfx/)
+obj/snes-sa1.o        : $(snes)/chip/sa1/sa1.cpp $(call rwildcard,$(snes)/chip/sa1/)
+obj/snes-necdsp.o     : $(snes)/chip/necdsp/necdsp.cpp $(call rwildcard,$(snes)/chip/necdsp/)
+obj/snes-bsx.o        : $(snes)/chip/bsx/bsx.cpp $(call rwildcard,$(snes)/chip/bsx/)
+obj/snes-srtc.o       : $(snes)/chip/srtc/srtc.cpp $(snes)/chip/srtc/*
+obj/snes-sdd1.o       : $(snes)/chip/sdd1/sdd1.cpp $(snes)/chip/sdd1/*
+obj/snes-spc7110.o    : $(snes)/chip/spc7110/spc7110.cpp $(snes)/chip/spc7110/*
+obj/snes-cx4.o        : $(snes)/chip/cx4/cx4.cpp $(snes)/chip/cx4/*
+obj/snes-obc1.o       : $(snes)/chip/obc1/obc1.cpp $(snes)/chip/obc1/*
+obj/snes-st0018.o     : $(snes)/chip/st0018/st0018.cpp $(snes)/chip/st0018/*
+obj/snes-sufamiturbo.o: $(snes)/chip/sufamiturbo/sufamiturbo.cpp $(snes)/chip/sufamiturbo/*
+obj/snes-msu1.o       : $(snes)/chip/msu1/msu1.cpp $(snes)/chip/msu1/*
+obj/snes-serial.o     : $(snes)/chip/serial/serial.cpp $(snes)/chip/serial/*

bsnes/snes/alt/cpu/cpu.cpp

@@ -1,4 +1,4 @@
-#include <snes.hpp>
+#include <snes/snes.hpp>
 
 #define CPU_CPP
 namespace SNES {
@@ -90,6 +90,30 @@ void CPU::op_irq(uint16 vector) {
   regs.pc.w = rd.w;
 }
 
+void CPU::enable() {
+  function<uint8 (unsigned)> read = { &CPU::mmio_read, (CPU*)&cpu };
+  function<void (unsigned, uint8)> write = { &CPU::mmio_write, (CPU*)&cpu };
+
+  bus.map(Bus::MapMode::Direct, 0x00, 0x3f, 0x2140, 0x2183, read, write);
+  bus.map(Bus::MapMode::Direct, 0x80, 0xbf, 0x2140, 0x2183, read, write);
+
+  bus.map(Bus::MapMode::Direct, 0x00, 0x3f, 0x4016, 0x4017, read, write);
+  bus.map(Bus::MapMode::Direct, 0x80, 0xbf, 0x4016, 0x4017, read, write);
+
+  bus.map(Bus::MapMode::Direct, 0x00, 0x3f, 0x4200, 0x421f, read, write);
+  bus.map(Bus::MapMode::Direct, 0x80, 0xbf, 0x4200, 0x421f, read, write);
+
+  bus.map(Bus::MapMode::Direct, 0x00, 0x3f, 0x4300, 0x437f, read, write);
+  bus.map(Bus::MapMode::Direct, 0x80, 0xbf, 0x4300, 0x437f, read, write);
+
+  read = [](unsigned addr) { return cpu.wram[addr]; };
+  write = [](unsigned addr, uint8 data) { cpu.wram[addr] = data; };
+
+  bus.map(Bus::MapMode::Linear, 0x00, 0x3f, 0x0000, 0x1fff, read, write, 0x000000, 0x002000);
+  bus.map(Bus::MapMode::Linear, 0x80, 0xbf, 0x0000, 0x1fff, read, write, 0x000000, 0x002000);
+  bus.map(Bus::MapMode::Linear, 0x7e, 0x7f, 0x0000, 0xffff, read, write);
+}
+
 void CPU::power() {
   regs.a = 0x0000;
   regs.x = 0x0000;

bsnes/snes/alt/cpu/cpu.hpp

@@ -1,5 +1,7 @@
-class CPU : public Processor, public CPUcore, public PPUcounter, public MMIO {
+class CPU : public Processor, public CPUcore, public PPUcounter {
 public:
+  uint8 wram[128 * 1024];
+
   enum : bool { Threaded = true };
   array<Processor*> coprocessors;
   alwaysinline void step(unsigned clocks);
@@ -20,6 +22,7 @@ public:
   debugvirtual void op_write(unsigned addr, uint8 data);
 
   void enter();
+  void enable();
   void power();
   void reset();
 

bsnes/snes/alt/cpu/debugger/debugger.cpp

@@ -8,13 +8,11 @@ void CPUDebugger::op_step() {
   opcode_pc = regs.pc;
 
   opcode_edge = true;
-  if(debugger.step_cpu) {
+  debugger.breakpoint_test(Debugger::Breakpoint::Source::CPUBus, Debugger::Breakpoint::Mode::Exec, regs.pc, 0x00);
+  if(step_event && step_event()) {
     debugger.break_event = Debugger::BreakEvent::CPUStep;
     scheduler.exit(Scheduler::ExitReason::DebuggerEvent);
-  } else {
-    debugger.breakpoint_test(Debugger::Breakpoint::Source::CPUBus, Debugger::Breakpoint::Mode::Exec, regs.pc, 0x00);
   }
-  if(step_event) step_event();
   opcode_edge = false;
 
   CPU::op_step();

bsnes/snes/alt/cpu/debugger/debugger.hpp

@@ -2,7 +2,7 @@ class CPUDebugger : public CPU, public ChipDebugger {
 public:
   bool property(unsigned id, string &name, string &value);
 
-  function<void ()> step_event;
+  function<bool ()> step_event;
 
   enum Usage {
     UsageRead  = 0x80,

bsnes/snes/alt/cpu/serialization.cpp

@@ -5,6 +5,8 @@ void CPU::serialize(serializer &s) {
   CPUcore::core_serialize(s);
   PPUcounter::serialize(s);
 
+  s.array(wram);
+
   queue.serialize(s);
   s.array(port_data);
 

bsnes/snes/alt/dsp/dsp.cpp

@@ -1,4 +1,4 @@
-#include <snes.hpp>
+#include <snes/snes.hpp>
 
 #define DSP_CPP
 namespace SNES {
@@ -40,7 +40,7 @@ void DSP::write(uint8 addr, uint8 data) {
 }
 
 void DSP::power() {
-  spc_dsp.init(memory::apuram.data());
+  spc_dsp.init(smp.apuram);
   spc_dsp.reset();
   spc_dsp.set_output(samplebuffer, 8192);
 }

bsnes/snes/alt/ppu-compatibility/memory/memory.cpp

@@ -26,7 +26,7 @@ uint8 PPU::vram_mmio_read(uint16 addr) {
   uint8 data;
 
   if(regs.display_disabled == true) {
-    data = memory::vram[addr];
+    data = vram[addr];
   } else {
     uint16 v = cpu.vcounter();
     uint16 h = cpu.hcounter();
@@ -39,12 +39,12 @@ uint8 PPU::vram_mmio_read(uint16 addr) {
       data = 0x00;
     } else if(v == (!overscan() ? 224 : 239)) {
       if(h == 1362) {
-        data = memory::vram[addr];
+        data = vram[addr];
       } else {
         data = 0x00;
       }
     } else {
-      data = memory::vram[addr];
+      data = vram[addr];
     }
   }
 
@@ -53,15 +53,15 @@ uint8 PPU::vram_mmio_read(uint16 addr) {
 
 void PPU::vram_mmio_write(uint16 addr, uint8 data) {
   if(regs.display_disabled == true) {
-    memory::vram[addr] = data;
+    vram[addr] = data;
   } else {
     uint16 v = cpu.vcounter();
     uint16 h = cpu.hcounter();
     if(v == 0) {
       if(h <= 4) {
-        memory::vram[addr] = data;
+        vram[addr] = data;
       } else if(h == 6) {
-        memory::vram[addr] = cpu.regs.mdr;
+        vram[addr] = cpu.regs.mdr;
       } else {
         //no write
       }
@@ -71,10 +71,10 @@ void PPU::vram_mmio_write(uint16 addr, uint8 data) {
       if(h <= 4) {
         //no write
       } else {
-        memory::vram[addr] = data;
+        vram[addr] = data;
       }
     } else {
-      memory::vram[addr] = data;
+      vram[addr] = data;
     }
   }
 }
@@ -85,12 +85,12 @@ uint8 PPU::oam_mmio_read(uint16 addr) {
   uint8 data;
 
   if(regs.display_disabled == true) {
-    data = memory::oam[addr];
+    data = oam[addr];
   } else {
     if(cpu.vcounter() < (!overscan() ? 225 : 240)) {
-      data = memory::oam[regs.ioamaddr];
+      data = oam[regs.ioamaddr];
     } else {
-      data = memory::oam[addr];
+      data = oam[addr];
     }
   }
 
@@ -104,14 +104,14 @@ void PPU::oam_mmio_write(uint16 addr, uint8 data) {
   sprite_list_valid = false;
 
   if(regs.display_disabled == true) {
-    memory::oam[addr] = data;
+    oam[addr] = data;
     update_sprite_list(addr, data);
   } else {
     if(cpu.vcounter() < (!overscan() ? 225 : 240)) {
-      memory::oam[regs.ioamaddr] = data;
+      oam[regs.ioamaddr] = data;
       update_sprite_list(regs.ioamaddr, data);
     } else {
-      memory::oam[addr] = data;
+      oam[addr] = data;
       update_sprite_list(addr, data);
     }
   }
@@ -122,14 +122,14 @@ uint8 PPU::cgram_mmio_read(uint16 addr) {
   uint8 data;
 
   if(1 || regs.display_disabled == true) {
-    data = memory::cgram[addr];
+    data = cgram[addr];
   } else {
     uint16 v = cpu.vcounter();
     uint16 h = cpu.hcounter();
     if(v < (!overscan() ? 225 : 240) && h >= 128 && h < 1096) {
-      data = memory::cgram[regs.icgramaddr] & 0x7f;
+      data = cgram[regs.icgramaddr] & 0x7f;
     } else {
-      data = memory::cgram[addr];
+      data = cgram[addr];
     }
   }
 
@@ -142,14 +142,14 @@ void PPU::cgram_mmio_write(uint16 addr, uint8 data) {
   if(addr & 1) data &= 0x7f;
 
   if(1 || regs.display_disabled == true) {
-    memory::cgram[addr] = data;
+    cgram[addr] = data;
   } else {
     uint16 v = cpu.vcounter();
     uint16 h = cpu.hcounter();
     if(v < (!overscan() ? 225 : 240) && h >= 128 && h < 1096) {
-      memory::cgram[regs.icgramaddr] = data & 0x7f;
+      cgram[regs.icgramaddr] = data & 0x7f;
     } else {
-      memory::cgram[addr] = data;
+      cgram[addr] = data;
     }
   }
 }

bsnes/snes/alt/ppu-compatibility/ppu.cpp

@@ -1,4 +1,4 @@
-#include <snes.hpp>
+#include <snes/snes.hpp>
 
 #define PPU_CPP
 namespace SNES {
@@ -122,13 +122,21 @@ void PPU::frame() {
   framecounter = (frameskip == 0 ? 0 : (framecounter + 1) % frameskip);
 }
 
+void PPU::enable() {
+  function<uint8 (unsigned)> read = { &PPU::mmio_read, (PPU*)&ppu };
+  function<void (unsigned, uint8)> write = { &PPU::mmio_write, (PPU*)&ppu };
+
+  bus.map(Bus::MapMode::Direct, 0x00, 0x3f, 0x2100, 0x213f, read, write);
+  bus.map(Bus::MapMode::Direct, 0x80, 0xbf, 0x2100, 0x213f, read, write);
+}
+
 void PPU::power() {
   ppu1_version = config.ppu1.version;
   ppu2_version = config.ppu2.version;
 
-  for(unsigned i = 0; i < memory::vram.size();  i++) memory::vram[i]  = 0x00;
-  for(unsigned i = 0; i < memory::oam.size();   i++) memory::oam[i]   = 0x00;
-  for(unsigned i = 0; i < memory::cgram.size(); i++) memory::cgram[i] = 0x00;
+  foreach(n, vram) n = 0x00;
+  foreach(n, oam) n = 0x00;
+  foreach(n, cgram) n = 0x00;
   flush_tiledata_cache();
 
   region = (system.region() == System::Region::NTSC ? 0 : 1);  //0 = NTSC, 1 = PAL

bsnes/snes/alt/ppu-compatibility/ppu.hpp

@@ -1,5 +1,9 @@
-class PPU : public Processor, public PPUcounter, public MMIO {
+class PPU : public Processor, public PPUcounter {
 public:
+  uint8 vram[128 * 1024];
+  uint8 oam[544];
+  uint8 cgram[512];
+
   enum : bool { Threaded = true };
   alwaysinline void step(unsigned clocks);
   alwaysinline void synchronize_cpu();
@@ -56,6 +60,7 @@ public:
   void render_scanline();
   void frame();
   void enter();
+  void enable();
   void power();
   void reset();
 

bsnes/snes/alt/ppu-compatibility/render/bg.cpp

@@ -32,7 +32,7 @@ uint16 PPU::bg_get_tile(uint16 x, uint16 y) {
   if(x & 0x20) pos += bg_info[bg].scx;
 
   const uint16 addr = regs.bg_scaddr[bg] + (pos << 1);
-  return memory::vram[addr] + (memory::vram[addr + 1] << 8);
+  return vram[addr] + (vram[addr + 1] << 8);
 }
 
 #define setpixel_main(x) \

bsnes/snes/alt/ppu-compatibility/render/cache.cpp

@@ -32,8 +32,8 @@ void PPU::render_bg_tile(uint16 tile_num) {
     unsigned pos = tile_num * 16;
     unsigned y = 8;
     while(y--) {
-      d0 = memory::vram[pos    ];
-      d1 = memory::vram[pos + 1];
+      d0 = vram[pos    ];
+      d1 = vram[pos + 1];
       render_bg_tile_line_2bpp(0x80);
       render_bg_tile_line_2bpp(0x40);
       render_bg_tile_line_2bpp(0x20);
@@ -52,10 +52,10 @@ void PPU::render_bg_tile(uint16 tile_num) {
     unsigned pos = tile_num * 32;
     unsigned y = 8;
     while(y--) {
-      d0 = memory::vram[pos     ];
-      d1 = memory::vram[pos +  1];
-      d2 = memory::vram[pos + 16];
-      d3 = memory::vram[pos + 17];
+      d0 = vram[pos     ];
+      d1 = vram[pos +  1];
+      d2 = vram[pos + 16];
+      d3 = vram[pos + 17];
       render_bg_tile_line_4bpp(0x80);
       render_bg_tile_line_4bpp(0x40);
       render_bg_tile_line_4bpp(0x20);
@@ -74,14 +74,14 @@ void PPU::render_bg_tile(uint16 tile_num) {
     unsigned pos = tile_num * 64;
     unsigned y = 8;
     while(y--) {
-      d0 = memory::vram[pos     ];
-      d1 = memory::vram[pos +  1];
-      d2 = memory::vram[pos + 16];
-      d3 = memory::vram[pos + 17];
-      d4 = memory::vram[pos + 32];
-      d5 = memory::vram[pos + 33];
-      d6 = memory::vram[pos + 48];
-      d7 = memory::vram[pos + 49];
+      d0 = vram[pos     ];
+      d1 = vram[pos +  1];
+      d2 = vram[pos + 16];
+      d3 = vram[pos + 17];
+      d4 = vram[pos + 32];
+      d5 = vram[pos + 33];
+      d6 = vram[pos + 48];
+      d7 = vram[pos + 49];
       render_bg_tile_line_8bpp(0x80);
       render_bg_tile_line_8bpp(0x40);
       render_bg_tile_line_8bpp(0x20);

bsnes/snes/alt/ppu-compatibility/render/line.cpp

@@ -2,7 +2,7 @@
 
 inline uint16 PPU::get_palette(uint8 index) {
   const unsigned addr = index << 1;
-  return memory::cgram[addr] + (memory::cgram[addr + 1] << 8);
+  return cgram[addr] + (cgram[addr + 1] << 8);
 }
 
 //p = 00000bgr <palette data>

bsnes/snes/alt/ppu-compatibility/render/mode7.cpp

@@ -71,8 +71,8 @@ void PPU::render_line_mode7(uint8 pri0_pos, uint8 pri1_pos) {
         py &= 1023;
         tx = ((px >> 3) & 127);
         ty = ((py >> 3) & 127);
-        tile    = memory::vram[(ty * 128 + tx) << 1];
-        palette = memory::vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
+        tile    = vram[(ty * 128 + tx) << 1];
+        palette = vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
       } break;
       case 2: {  //palette color 0 outside of screen area
         if((px | py) & ~1023) {
@@ -82,8 +82,8 @@ void PPU::render_line_mode7(uint8 pri0_pos, uint8 pri1_pos) {
           py &= 1023;
           tx = ((px >> 3) & 127);
           ty = ((py >> 3) & 127);
-          tile    = memory::vram[(ty * 128 + tx) << 1];
-          palette = memory::vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
+          tile    = vram[(ty * 128 + tx) << 1];
+          palette = vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
         }
       } break;
       case 3: {  //character 0 repetition outside of screen area
@@ -94,9 +94,9 @@ void PPU::render_line_mode7(uint8 pri0_pos, uint8 pri1_pos) {
           py &= 1023;
           tx = ((px >> 3) & 127);
           ty = ((py >> 3) & 127);
-          tile = memory::vram[(ty * 128 + tx) << 1];
+          tile = vram[(ty * 128 + tx) << 1];
         }
-        palette = memory::vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
+        palette = vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
       } break;
     }
 

bsnes/snes/alt/ppu-compatibility/serialization.cpp

@@ -16,6 +16,10 @@ void PPU::serialize(serializer &s) {
   Processor::serialize(s);
   PPUcounter::serialize(s);
 
+  s.array(vram);
+  s.array(oam);
+  s.array(cgram);
+
   s.integer(ppu1_version);
   s.integer(ppu2_version);
 

bsnes/snes/alt/ppu-performance/background/background.cpp

@@ -11,7 +11,7 @@ unsigned PPU::Background::get_tile(unsigned hoffset, unsigned voffset) {
   if(tile_x & 0x20) tile_pos += scx;
 
   const uint16 tiledata_addr = regs.screen_addr + (tile_pos << 1);
-  return (memory::vram[tiledata_addr + 0] << 0) + (memory::vram[tiledata_addr + 1] << 8);
+  return (ppu.vram[tiledata_addr + 0] << 0) + (ppu.vram[tiledata_addr + 1] << 8);
 }
 
 void PPU::Background::offset_per_tile(unsigned x, unsigned y, unsigned &hoffset, unsigned &voffset) {

bsnes/snes/alt/ppu-performance/background/mode7.cpp

@@ -43,8 +43,8 @@ void PPU::Background::render_mode7() {
         py &= 1023;
         tx = ((px >> 3) & 127);
         ty = ((py >> 3) & 127);
-        tile = memory::vram[(ty * 128 + tx) << 1];
-        palette = memory::vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
+        tile = ppu.vram[(ty * 128 + tx) << 1];
+        palette = ppu.vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
         break;
       }
 
@@ -56,8 +56,8 @@ void PPU::Background::render_mode7() {
           py &= 1023;
           tx = ((px >> 3) & 127);
           ty = ((py >> 3) & 127);
-          tile = memory::vram[(ty * 128 + tx) << 1];
-          palette = memory::vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
+          tile = ppu.vram[(ty * 128 + tx) << 1];
+          palette = ppu.vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
         }
         break;
       }
@@ -70,9 +70,9 @@ void PPU::Background::render_mode7() {
           py &= 1023;
           tx = ((px >> 3) & 127);
           ty = ((py >> 3) & 127);
-          tile = memory::vram[(ty * 128 + tx) << 1];
+          tile = ppu.vram[(ty * 128 + tx) << 1];
         }
-        palette = memory::vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
+        palette = ppu.vram[(((tile << 6) + ((py & 7) << 3) + (px & 7)) << 1) + 1];
         break;
       }
     }

bsnes/snes/alt/ppu-performance/cache/cache.cpp

@@ -8,8 +8,8 @@ uint8* PPU::Cache::tile_2bpp(unsigned tile) {
     unsigned y = 8;
     unsigned color, d0, d1;
     while(y--) {
-      d0 = memory::vram[offset +  0];
-      d1 = memory::vram[offset +  1];
+      d0 = ppu.vram[offset +  0];
+      d1 = ppu.vram[offset +  1];
       #define render_line(mask) \
         color  = !!(d0 & mask) << 0; \
         color |= !!(d1 & mask) << 1; \
@@ -37,10 +37,10 @@ uint8* PPU::Cache::tile_4bpp(unsigned tile) {
     unsigned y = 8;
     unsigned color, d0, d1, d2, d3;
     while(y--) {
-      d0 = memory::vram[offset +  0];
-      d1 = memory::vram[offset +  1];
-      d2 = memory::vram[offset + 16];
-      d3 = memory::vram[offset + 17];
+      d0 = ppu.vram[offset +  0];
+      d1 = ppu.vram[offset +  1];
+      d2 = ppu.vram[offset + 16];
+      d3 = ppu.vram[offset + 17];
       #define render_line(mask) \
         color  = !!(d0 & mask) << 0; \
         color |= !!(d1 & mask) << 1; \
@@ -70,14 +70,14 @@ uint8* PPU::Cache::tile_8bpp(unsigned tile) {
     unsigned y = 8;
     unsigned color, d0, d1, d2, d3, d4, d5, d6, d7;
     while(y--) {
-      d0 = memory::vram[offset +  0];
-      d1 = memory::vram[offset +  1];
-      d2 = memory::vram[offset + 16];
-      d3 = memory::vram[offset + 17];
-      d4 = memory::vram[offset + 32];
-      d5 = memory::vram[offset + 33];
-      d6 = memory::vram[offset + 48];
-      d7 = memory::vram[offset + 49];
+      d0 = ppu.vram[offset +  0];
+      d1 = ppu.vram[offset +  1];
+      d2 = ppu.vram[offset + 16];
+      d3 = ppu.vram[offset + 17];
+      d4 = ppu.vram[offset + 32];
+      d5 = ppu.vram[offset + 33];
+      d6 = ppu.vram[offset + 48];
+      d7 = ppu.vram[offset + 49];
       #define render_line(mask) \
         color  = !!(d0 & mask) << 0; \
         color |= !!(d1 & mask) << 1; \

bsnes/snes/alt/ppu-performance/mmio/mmio.cpp

@@ -22,14 +22,14 @@ uint16 PPU::get_vram_addr() {
 }
 
 uint8 PPU::vram_read(unsigned addr) {
-  if(regs.display_disable) return memory::vram[addr];
-  if(cpu.vcounter() >= display.height) return memory::vram[addr];
+  if(regs.display_disable) return vram[addr];
+  if(cpu.vcounter() >= display.height) return vram[addr];
   return 0x00;
 }
 
 void PPU::vram_write(unsigned addr, uint8 data) {
   if(regs.display_disable || cpu.vcounter() >= display.height) {
-    memory::vram[addr] = data;
+    vram[addr] = data;
     cache.tilevalid[0][addr >> 4] = false;
     cache.tilevalid[1][addr >> 5] = false;
     cache.tilevalid[2][addr >> 6] = false;
@@ -39,24 +39,24 @@ void PPU::vram_write(unsigned addr, uint8 data) {
 
 uint8 PPU::oam_read(unsigned addr) {
   if(addr & 0x0200) addr &= 0x021f;
-  if(regs.display_disable) return memory::oam[addr];
-  if(cpu.vcounter() >= display.height) return memory::oam[addr];
-  return memory::oam[0x0218];
+  if(regs.display_disable) return oam[addr];
+  if(cpu.vcounter() >= display.height) return oam[addr];
+  return oam[0x0218];
 }
 
 void PPU::oam_write(unsigned addr, uint8 data) {
   if(addr & 0x0200) addr &= 0x021f;
   if(!regs.display_disable && cpu.vcounter() < display.height) addr = 0x0218;
-  memory::oam[addr] = data;
-  oam.update_list(addr, data);
+  oam[addr] = data;
+  sprite.update_list(addr, data);
 }
 
 uint8 PPU::cgram_read(unsigned addr) {
-  return memory::cgram[addr];
+  return cgram[addr];
 }
 
 void PPU::cgram_write(unsigned addr, uint8 data) {
-  memory::cgram[addr] = data;
+  cgram[addr] = data;
 }
 
 void PPU::mmio_update_video_mode() {
@@ -66,7 +66,7 @@ void PPU::mmio_update_video_mode() {
       bg2.regs.mode = Background::Mode::BPP2; bg2.regs.priority0 = 7; bg2.regs.priority1 = 10;
       bg3.regs.mode = Background::Mode::BPP2; bg3.regs.priority0 = 2; bg3.regs.priority1 =  5;
       bg4.regs.mode = Background::Mode::BPP2; bg4.regs.priority0 = 1; bg4.regs.priority1 =  4;
-      oam.regs.priority0 = 3; oam.regs.priority1 = 6; oam.regs.priority2 = 9; oam.regs.priority3 = 12;
+      sprite.regs.priority0 = 3; sprite.regs.priority1 = 6; sprite.regs.priority2 = 9; sprite.regs.priority3 = 12;
     } break;
 
     case 1: {
@@ -78,12 +78,12 @@ void PPU::mmio_update_video_mode() {
         bg1.regs.priority0 = 5; bg1.regs.priority1 =  8;
         bg2.regs.priority0 = 4; bg2.regs.priority1 =  7;
         bg3.regs.priority0 = 1; bg3.regs.priority1 = 10;
-        oam.regs.priority0 = 2; oam.regs.priority1 = 3; oam.regs.priority2 = 6; oam.regs.priority3 = 9;
+        sprite.regs.priority0 = 2; sprite.regs.priority1 = 3; sprite.regs.priority2 = 6; sprite.regs.priority3 = 9;
       } else {
         bg1.regs.priority0 = 6; bg1.regs.priority1 =  9;
         bg2.regs.priority0 = 5; bg2.regs.priority1 =  8;
         bg3.regs.priority0 = 1; bg3.regs.priority1 =  3;
-        oam.regs.priority0 = 2; oam.regs.priority1 = 4; oam.regs.priority2 = 7; oam.regs.priority3 = 10;
+        sprite.regs.priority0 = 2; sprite.regs.priority1 = 4; sprite.regs.priority2 = 7; sprite.regs.priority3 = 10;
       }
     } break;
 
@@ -94,7 +94,7 @@ void PPU::mmio_update_video_mode() {
       bg4.regs.mode = Background::Mode::Inactive;
       bg1.regs.priority0 = 3; bg1.regs.priority1 = 7;
       bg2.regs.priority0 = 1; bg2.regs.priority1 = 5;
-      oam.regs.priority0 = 2; oam.regs.priority1 = 4; oam.regs.priority2 = 6; oam.regs.priority3 = 8;
+      sprite.regs.priority0 = 2; sprite.regs.priority1 = 4; sprite.regs.priority2 = 6; sprite.regs.priority3 = 8;
     } break;
 
     case 3: {
@@ -104,7 +104,7 @@ void PPU::mmio_update_video_mode() {
       bg4.regs.mode = Background::Mode::Inactive;
       bg1.regs.priority0 = 3; bg1.regs.priority1 = 7;
       bg2.regs.priority0 = 1; bg2.regs.priority1 = 5;
-      oam.regs.priority0 = 2; oam.regs.priority1 = 4; oam.regs.priority2 = 6; oam.regs.priority3 = 8;
+      sprite.regs.priority0 = 2; sprite.regs.priority1 = 4; sprite.regs.priority2 = 6; sprite.regs.priority3 = 8;
     } break;
 
     case 4: {
@@ -114,7 +114,7 @@ void PPU::mmio_update_video_mode() {
       bg4.regs.mode = Background::Mode::Inactive;
       bg1.regs.priority0 = 3; bg1.regs.priority1 = 7;
       bg2.regs.priority0 = 1; bg2.regs.priority1 = 5;
-      oam.regs.priority0 = 2; oam.regs.priority1 = 4; oam.regs.priority2 = 6; oam.regs.priority3 = 8;
+      sprite.regs.priority0 = 2; sprite.regs.priority1 = 4; sprite.regs.priority2 = 6; sprite.regs.priority3 = 8;
     } break;
 
     case 5: {
@@ -124,7 +124,7 @@ void PPU::mmio_update_video_mode() {
       bg4.regs.mode = Background::Mode::Inactive;
       bg1.regs.priority0 = 3; bg1.regs.priority1 = 7;
       bg2.regs.priority0 = 1; bg2.regs.priority1 = 5;
-      oam.regs.priority0 = 2; oam.regs.priority1 = 4; oam.regs.priority2 = 6; oam.regs.priority3 = 8;
+      sprite.regs.priority0 = 2; sprite.regs.priority1 = 4; sprite.regs.priority2 = 6; sprite.regs.priority3 = 8;
     } break;
 
     case 6: {
@@ -133,7 +133,7 @@ void PPU::mmio_update_video_mode() {
       bg3.regs.mode = Background::Mode::Inactive;
       bg4.regs.mode = Background::Mode::Inactive;
       bg1.regs.priority0 = 2; bg1.regs.priority1 = 5;
-      oam.regs.priority0 = 1; oam.regs.priority1 = 3; oam.regs.priority2 = 4; oam.regs.priority3 = 6;
+      sprite.regs.priority0 = 1; sprite.regs.priority1 = 3; sprite.regs.priority2 = 4; sprite.regs.priority3 = 6;
     } break;
 
     case 7: {
@@ -143,7 +143,7 @@ void PPU::mmio_update_video_mode() {
         bg3.regs.mode = Background::Mode::Inactive;
         bg4.regs.mode = Background::Mode::Inactive;
         bg1.regs.priority0 = 2; bg1.regs.priority1 = 2;
-        oam.regs.priority0 = 1; oam.regs.priority1 = 3; oam.regs.priority2 = 4; oam.regs.priority3 = 5;
+        sprite.regs.priority0 = 1; sprite.regs.priority1 = 3; sprite.regs.priority2 = 4; sprite.regs.priority3 = 5;
       } else {
         bg1.regs.mode = Background::Mode::Mode7;
         bg2.regs.mode = Background::Mode::Mode7;
@@ -151,7 +151,7 @@ void PPU::mmio_update_video_mode() {
         bg4.regs.mode = Background::Mode::Inactive;
         bg1.regs.priority0 = 3; bg1.regs.priority1 = 3;
         bg2.regs.priority0 = 1; bg2.regs.priority1 = 5;
-        oam.regs.priority0 = 2; oam.regs.priority1 = 4; oam.regs.priority2 = 6; oam.regs.priority3 = 7;
+        sprite.regs.priority0 = 2; sprite.regs.priority1 = 4; sprite.regs.priority2 = 6; sprite.regs.priority3 = 7;
       }
     } break;
   }
@@ -193,7 +193,7 @@ uint8 PPU::mmio_read(unsigned addr) {
     case 0x2138: {  //OAMDATAREAD
       regs.ppu1_mdr = oam_read(regs.oam_addr);
       regs.oam_addr = (regs.oam_addr + 1) & 0x03ff;
-      oam.set_first();
+      sprite.set_first();
       return regs.ppu1_mdr;
     }
 
@@ -251,8 +251,8 @@ uint8 PPU::mmio_read(unsigned addr) {
 
     case 0x213e: {  //STAT77
       regs.ppu1_mdr &= 0x10;
-      regs.ppu1_mdr |= oam.regs.time_over << 7;
-      regs.ppu1_mdr |= oam.regs.range_over << 6;
+      regs.ppu1_mdr |= sprite.regs.time_over << 7;
+      regs.ppu1_mdr |= sprite.regs.range_over << 6;
       regs.ppu1_mdr |= 0x01;  //version
       return regs.ppu1_mdr;
     }
@@ -283,30 +283,30 @@ void PPU::mmio_write(unsigned addr, uint8 data) {
 
   switch(addr & 0xffff) {
     case 0x2100: {  //INIDISP
-      if(regs.display_disable && cpu.vcounter() == display.height) oam.address_reset();
+      if(regs.display_disable && cpu.vcounter() == display.height) sprite.address_reset();
       regs.display_disable = data & 0x80;
       regs.display_brightness = data & 0x0f;
       return;
     }
 
     case 0x2101: {  //OBSEL
-      oam.regs.base_size = (data >> 5) & 7;
-      oam.regs.nameselect = (data >> 3) & 3;
-      oam.regs.tiledata_addr = (data & 3) << 14;
-      oam.list_valid = false;
+      sprite.regs.base_size = (data >> 5) & 7;
+      sprite.regs.nameselect = (data >> 3) & 3;
+      sprite.regs.tiledata_addr = (data & 3) << 14;
+      sprite.list_valid = false;
       return;
     }
 
     case 0x2102: {  //OAMADDL
       regs.oam_baseaddr = (regs.oam_baseaddr & 0x0100) | (data << 0);
-      oam.address_reset();
+      sprite.address_reset();
       return;
     }
 
     case 0x2103: {  //OAMADDH
       regs.oam_priority = data & 0x80;
       regs.oam_baseaddr = ((data & 1) << 8) | (regs.oam_baseaddr & 0x00ff);
-      oam.address_reset();
+      sprite.address_reset();
       return;
     }
 
@@ -319,7 +319,7 @@ void PPU::mmio_write(unsigned addr, uint8 data) {
         oam_write((regs.oam_addr & ~1) + 1, data);
       }
       regs.oam_addr = (regs.oam_addr + 1) & 0x03ff;
-      oam.set_first();
+      sprite.set_first();
       return;
     }
 
@@ -561,10 +561,10 @@ void PPU::mmio_write(unsigned addr, uint8 data) {
       screen.window.two_invert = data & 0x40;
       screen.window.one_enable = data & 0x20;
       screen.window.one_invert = data & 0x10;
-      oam.window.two_enable = data & 0x08;
-      oam.window.two_invert = data & 0x04;
-      oam.window.one_enable = data & 0x02;
-      oam.window.one_invert = data & 0x01;
+      sprite.window.two_enable = data & 0x08;
+      sprite.window.two_invert = data & 0x04;
+      sprite.window.one_enable = data & 0x02;
+      sprite.window.one_invert = data & 0x01;
       return;
     }
 
@@ -598,12 +598,12 @@ void PPU::mmio_write(unsigned addr, uint8 data) {
 
     case 0x212b: {  //WOBJLOG
       screen.window.mask = (data >> 2) & 3;
-      oam.window.mask = (data >> 0) & 3;
+      sprite.window.mask = (data >> 0) & 3;
       return;
     }
 
     case 0x212c: {  //TM
-      oam.regs.main_enable = data & 0x10;
+      sprite.regs.main_enable = data & 0x10;
       bg4.regs.main_enable = data & 0x08;
       bg3.regs.main_enable = data & 0x04;
       bg2.regs.main_enable = data & 0x02;
@@ -612,7 +612,7 @@ void PPU::mmio_write(unsigned addr, uint8 data) {
     }
 
     case 0x212d: {  //TS
-      oam.regs.sub_enable = data & 0x10;
+      sprite.regs.sub_enable = data & 0x10;
       bg4.regs.sub_enable = data & 0x08;
       bg3.regs.sub_enable = data & 0x04;
       bg2.regs.sub_enable = data & 0x02;
@@ -621,7 +621,7 @@ void PPU::mmio_write(unsigned addr, uint8 data) {
     }
 
     case 0x212e: {  //TMW
-      oam.window.main_enable = data & 0x10;
+      sprite.window.main_enable = data & 0x10;
       bg4.window.main_enable = data & 0x08;
       bg3.window.main_enable = data & 0x04;
       bg2.window.main_enable = data & 0x02;
@@ -630,7 +630,7 @@ void PPU::mmio_write(unsigned addr, uint8 data) {
     }
 
     case 0x212f: {  //TSW
-      oam.window.sub_enable = data & 0x10;
+      sprite.window.sub_enable = data & 0x10;
       bg4.window.sub_enable = data & 0x08;
       bg3.window.sub_enable = data & 0x04;
       bg2.window.sub_enable = data & 0x02;
@@ -671,10 +671,10 @@ void PPU::mmio_write(unsigned addr, uint8 data) {
       regs.mode7_extbg = data & 0x40;
       regs.pseudo_hires = data & 0x08;
       regs.overscan = data & 0x04;
-      oam.regs.interlace = data & 0x02;
+      sprite.regs.interlace = data & 0x02;
       regs.interlace = data & 0x01;
       mmio_update_video_mode();
-      oam.list_valid = false;
+      sprite.list_valid = false;
       return;
     }
   }
@@ -695,17 +695,17 @@ void PPU::mmio_reset() {
   regs.latch_hcounter = 0;
   regs.latch_vcounter = 0;
 
-  oam.regs.first_sprite = 0;
-  oam.list_valid = false;
+  sprite.regs.first_sprite = 0;
+  sprite.list_valid = false;
 
   //$2100
   regs.display_disable = true;
   regs.display_brightness = 0;
 
   //$2101
-  oam.regs.base_size = 0;
-  oam.regs.nameselect = 0;
-  oam.regs.tiledata_addr = 0;
+  sprite.regs.base_size = 0;
+  sprite.regs.nameselect = 0;
+  sprite.regs.tiledata_addr = 0;
 
   //$2102-$2103
   regs.oam_baseaddr = 0;
@@ -799,10 +799,10 @@ void PPU::mmio_reset() {
   bg4.window.two_enable = 0;
   bg4.window.two_invert = 0;
 
-  oam.window.one_enable = 0;
-  oam.window.one_invert = 0;
-  oam.window.two_enable = 0;
-  oam.window.two_invert = 0;
+  sprite.window.one_enable = 0;
+  sprite.window.one_invert = 0;
+  sprite.window.two_enable = 0;
+  sprite.window.two_invert = 0;
 
   screen.window.one_enable = 0;
   screen.window.one_invert = 0;
@@ -820,7 +820,7 @@ void PPU::mmio_reset() {
   bg2.window.mask = 0;
   bg3.window.mask = 0;
   bg4.window.mask = 0;
-  oam.window.mask = 0;
+  sprite.window.mask = 0;
   screen.window.mask = 0;
 
   //$212c
@@ -828,28 +828,28 @@ void PPU::mmio_reset() {
   bg2.regs.main_enable = 0;
   bg3.regs.main_enable = 0;
   bg4.regs.main_enable = 0;
-  oam.regs.main_enable = 0;
+  sprite.regs.main_enable = 0;
 
   //$212d
   bg1.regs.sub_enable = 0;
   bg2.regs.sub_enable = 0;
   bg3.regs.sub_enable = 0;
   bg4.regs.sub_enable = 0;
-  oam.regs.sub_enable = 0;
+  sprite.regs.sub_enable = 0;
 
   //$212e
   bg1.window.main_enable = 0;
   bg2.window.main_enable = 0;
   bg3.window.main_enable = 0;
   bg4.window.main_enable = 0;
-  oam.window.main_enable = 0;
+  sprite.window.main_enable = 0;
 
   //$212f
   bg1.window.sub_enable = 0;
   bg2.window.sub_enable = 0;
   bg3.window.sub_enable = 0;
   bg4.window.sub_enable = 0;
-  oam.window.sub_enable = 0;
+  sprite.window.sub_enable = 0;
 
   //$2130
   screen.window.main_mask = 0;
@@ -878,12 +878,12 @@ void PPU::mmio_reset() {
   regs.mode7_extbg = 0;
   regs.pseudo_hires = 0;
   regs.overscan = 0;
-  oam.regs.interlace = 0;
+  sprite.regs.interlace = 0;
   regs.interlace = 0;
 
   //$213e
-  oam.regs.time_over = 0;
-  oam.regs.range_over = 0;
+  sprite.regs.time_over = 0;
+  sprite.regs.range_over = 0;
 
   mmio_update_video_mode();
 }

bsnes/snes/alt/ppu-performance/mmio/mmio.hpp

@@ -1,3 +1,9 @@
+public:
+  uint8 mmio_read(unsigned addr);
+  void mmio_write(unsigned addr, uint8 data);
+
+private:
+
 struct Regs {
   //internal
   uint8 ppu1_mdr;
@@ -86,6 +92,4 @@ uint8 cgram_read(unsigned addr);
 void cgram_write(unsigned addr, uint8 data);
 
 void mmio_update_video_mode();
-uint8 mmio_read(unsigned addr);
-void mmio_write(unsigned addr, uint8 data);
 void mmio_reset();

bsnes/snes/alt/ppu-performance/ppu.cpp

@@ -1,4 +1,4 @@
-#include <snes.hpp>
+#include <snes/snes.hpp>
 
 #define PPU_CPP
 namespace SNES {
@@ -67,7 +67,7 @@ void PPU::render_scanline() {
   bg2.render();
   bg3.render();
   bg4.render();
-  oam.render();
+  sprite.render();
   screen.render();
 }
 
@@ -75,21 +75,29 @@ void PPU::scanline() {
   display.width = !hires() ? 256 : 512;
   display.height = !overscan() ? 225 : 240;
   if(vcounter() == 0) frame();
-  if(vcounter() == display.height && regs.display_disable == false) oam.address_reset();
+  if(vcounter() == display.height && regs.display_disable == false) sprite.address_reset();
 }
 
 void PPU::frame() {
-  oam.frame();
+  sprite.frame();
   system.frame();
   display.interlace = regs.interlace;
   display.overscan = regs.overscan;
   display.framecounter = display.frameskip == 0 ? 0 : (display.framecounter + 1) % display.frameskip;
 }
 
+void PPU::enable() {
+  function<uint8 (unsigned)> read = { &PPU::mmio_read, (PPU*)&ppu };
+  function<void (unsigned, uint8)> write = { &PPU::mmio_write, (PPU*)&ppu };
+
+  bus.map(Bus::MapMode::Direct, 0x00, 0x3f, 0x2100, 0x213f, read, write);
+  bus.map(Bus::MapMode::Direct, 0x80, 0xbf, 0x2100, 0x213f, read, write);
+}
+
 void PPU::power() {
-  foreach(n, memory::vram) n = 0;
-  foreach(n, memory::oam) n = 0;
-  foreach(n, memory::cgram) n = 0;
+  foreach(n, vram) n = 0;
+  foreach(n, oam) n = 0;
+  foreach(n, cgram) n = 0;
   reset();
 }
 
@@ -112,10 +120,10 @@ void PPU::layer_enable(unsigned layer, unsigned priority, bool enable) {
     case  9: bg3.priority1_enable = enable; break;
     case 12: bg4.priority0_enable = enable; break;
     case 13: bg4.priority1_enable = enable; break;
-    case 16: oam.priority0_enable = enable; break;
-    case 17: oam.priority1_enable = enable; break;
-    case 18: oam.priority2_enable = enable; break;
-    case 19: oam.priority3_enable = enable; break;
+    case 16: sprite.priority0_enable = enable; break;
+    case 17: sprite.priority1_enable = enable; break;
+    case 18: sprite.priority2_enable = enable; break;
+    case 19: sprite.priority3_enable = enable; break;
   }
 }
 
@@ -130,7 +138,7 @@ bg1(*this, Background::ID::BG1),
 bg2(*this, Background::ID::BG2),
 bg3(*this, Background::ID::BG3),
 bg4(*this, Background::ID::BG4),
-oam(*this),
+sprite(*this),
 screen(*this) {
   surface = new uint16[512 * 512];
   output = surface + 16 * 512;