Update to v080 release.

byuu says:

This release adds low-level emulation of the Hitachi HG51B169 DSP, which
was used in Mega Man X2 and Mega Man X3 as the Cx4 chip. It also fixes
a regression in both the sound core and cheat engine.

You will now need the HG51B169 data ROM to play MMX2/MMX3.

Once again, Cx4 LLE could not have been possible without the help of Dr.
Decapitator, Jonas Quinn, Overload and Segher. Be sure to thank them,
please!

Changelog:
* added Cx4 low-level emulation; removed Cx4 high-level emulation code
* fixed S-SMP synchronization to S-CPU on CPUIO writes
* controllers now have their own threads and classes
* serial controller is now emulated as an actual controller, rather than
  as a coprocessor
* added link coprocessor module for special chip research and homebrew
* fixed cheat codes that target mask ROM addresses [Cydrak]
* fixed compilation error with the latest GCC 4.6.0 beta releases
* added flexibility to XML memory mapping file format
* updated to mightymo's latest cheat pack (2011-06-20)

bsnes/Makefile

@@ -1,14 +1,18 @@
 include nall/Makefile
 snes := snes
+gameboy := gameboy
 profile := compatibility
-ui := ui-qt
+ui := ui
+
+# debugger
+options :=
 
 # 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
@@ -17,6 +21,8 @@ objects :=
 # profile-guided optimization
 # flags += -fprofile-use
 
+flags := $(flags) $(foreach o,$(call strupper,$(options)),-D$o)
+
 # platform
 ifeq ($(platform),x)
   link += -s -ldl -lX11 -lXext
@@ -45,36 +51,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 qt/data/bsnes.png $(DESTDIR)$(prefix)/share/pixmaps/bsnes.png
-	install -D -m 644 qt/data/bsnes.desktop $(DESTDIR)$(prefix)/share/applications/bsnes.desktop
-	gconftool-2 --type bool --set /desktop/gnome/interface/menus_have_icons true
-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)
@@ -88,6 +70,6 @@ clean: ui_clean
 	-@$(call delete,*.manifest)
 
 archive-all:
-	tar -cjf bsnes.tar.bz2 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 ui-libsnes Makefile cc.bat clean.bat sync.sh
 
 help:;

bsnes/cc.bat

@@ -1,2 +1,2 @@
-@mingw32-make -j 2
+@mingw32-make -j 8
 @pause

bsnes/data/bsnes.Manifest

@@ -1,9 +1,9 @@
 <?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"/>
+  <assemblyIdentity type="win32" name="bsnes" version="1.0.0.0" processorArchitecture="*"/>
   <dependency>
     <dependentAssembly>
-      <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="X86" publicKeyToken="6595b64144ccf1df" language="*"/>
+      <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/>
     </dependentAssembly>
   </dependency>
 </assembly>

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,105 @@
+#include <gameboy/gameboy.hpp>
+
+#define APU_CPP
+namespace GameBoy {
+
+#include "square1/square1.cpp"
+#include "square2/square2.cpp"
+#include "wave/wave.cpp"
+#include "noise/noise.cpp"
+#include "master/master.cpp"
+#include "serialization.cpp"
+APU apu;
+
+void APU::Main() {
+  apu.main();
+}
+
+void APU::main() {
+  while(true) {
+    if(scheduler.sync == Scheduler::SynchronizeMode::All) {
+      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
+    }
+
+    if(sequencer_base == 0) {  //512hz
+      if(sequencer_step == 0 || sequencer_step == 2 || sequencer_step == 4 || sequencer_step == 6) {  //256hz
+        square1.clock_length();
+        square2.clock_length();
+        wave.clock_length();
+        noise.clock_length();
+      }
+      if(sequencer_step == 2 || sequencer_step == 6) {  //128hz
+        square1.clock_sweep();
+      }
+      if(sequencer_step == 7) {  //64hz
+        square1.clock_envelope();
+        square2.clock_envelope();
+        noise.clock_envelope();
+      }
+      sequencer_step++;
+    }
+    sequencer_base++;
+
+    square1.run();
+    square2.run();
+    wave.run();
+    noise.run();
+    master.run();
+
+    system.interface->audio_sample(master.center, master.left, master.right);
+    if(++clock >= 0) co_switch(scheduler.active_thread = cpu.thread);
+  }
+}
+
+void APU::power() {
+  create(Main, 4194304);
+  for(unsigned n = 0xff10; n <= 0xff3f; n++) bus.mmio[n] = this;
+
+  foreach(n, mmio_data) n = 0x00;
+  sequencer_base = 0;
+  sequencer_step = 0;
+
+  square1.power();
+  square2.power();
+  wave.power();
+  noise.power();
+  master.power();
+}
+
+uint8 APU::mmio_read(uint16 addr) {
+  static const uint8 table[48] = {
+    0x80, 0x3f, 0x00, 0xff, 0xbf,                          //square1
+    0xff, 0x3f, 0x00, 0xff, 0xbf,                          //square2
+    0x7f, 0xff, 0x9f, 0xff, 0xbf,                          //wave
+    0xff, 0xff, 0x00, 0x00, 0xbf,                          //noise
+    0x00, 0x00, 0x70,                                      //master
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  //unmapped
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,        //wave pattern
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,        //wave pattern
+  };
+
+  if(addr == 0xff26) {
+    uint8 data = master.enable << 7;
+    if(square1.counter && square1.length) data |= 0x01;
+    if(square2.counter && square2.length) data |= 0x02;
+    if(   wave.counter &&    wave.length) data |= 0x04;
+    if(  noise.counter &&   noise.length) data |= 0x08;
+    return data | table[addr - 0xff10];
+  }
+
+  if(addr >= 0xff10 && addr <= 0xff3f) return mmio_data[addr - 0xff10] | table[addr - 0xff10];
+  return 0xff;
+}
+
+void APU::mmio_write(uint16 addr, uint8 data) {
+  if(addr >= 0xff10 && addr <= 0xff3f) mmio_data[addr - 0xff10] = data;
+
+  if(addr >= 0xff10 && addr <= 0xff14) return square1.write        (addr - 0xff10, data);
+  if(addr >= 0xff15 && addr <= 0xff19) return square2.write        (addr - 0xff15, data);
+  if(addr >= 0xff1a && addr <= 0xff1e) return    wave.write        (addr - 0xff1a, data);
+  if(addr >= 0xff1f && addr <= 0xff23) return   noise.write        (addr - 0xff1f, data);
+  if(addr >= 0xff24 && addr <= 0xff26) return  master.write        (addr - 0xff24, data);
+  if(addr >= 0xff30 && addr <= 0xff3f) return    wave.write_pattern(addr - 0xff30, data);
+}
+
+}

bsnes/gameboy/apu/apu.hpp

@@ -0,0 +1,28 @@
+struct APU : Processor, MMIO {
+  #include "square1/square1.hpp"
+  #include "square2/square2.hpp"
+  #include "wave/wave.hpp"
+  #include "noise/noise.hpp"
+  #include "master/master.hpp"
+
+  uint8 mmio_data[48];
+  uint13 sequencer_base;
+  uint3 sequencer_step;
+
+  Square1 square1;
+  Square2 square2;
+  Wave wave;
+  Noise noise;
+  Master master;
+
+  static void Main();
+  void main();
+  void power();
+
+  uint8 mmio_read(uint16 addr);
+  void mmio_write(uint16 addr, uint8 data);
+
+  void serialize(serializer&);
+};
+
+extern APU apu;

bsnes/gameboy/apu/master/master.cpp

@@ -0,0 +1,132 @@
+#ifdef APU_CPP
+
+void APU::Master::run() {
+  if(enable == false) {
+    center = 0;
+    left   = 0;
+    right  = 0;
+    return;
+  }
+
+  signed sample = 0, channels;
+  sample += apu.square1.output;
+  sample += apu.square2.output;
+  sample +=    apu.wave.output;
+  sample +=   apu.noise.output;
+  sample >>= 2;
+  center = sclamp<16>(sample);
+
+  if(left_enable == false && right_enable == false) {
+    left  = center;
+    right = center;
+    return;
+  }
+
+  sample = 0;
+  channels = 0;
+  if(channel1_left_enable) { sample += apu.square1.output; channels++; }
+  if(channel2_left_enable) { sample += apu.square2.output; channels++; }
+  if(channel3_left_enable) { sample +=    apu.wave.output; channels++; }
+  if(channel4_left_enable) { sample +=   apu.noise.output; channels++; }
+  if(channels) sample /= channels;
+  left = sclamp<16>(sample);
+
+  switch(left_volume) {
+    case 0: left >>= 3;                       break;  // 12.5%
+    case 1: left >>= 2;                       break;  // 25.0%
+    case 2: left = (left >> 2) + (left >> 3); break;  // 37.5%
+    case 3: left >>= 1;                       break;  // 50.0%
+    case 4: left = (left >> 1) + (left >> 3); break;  // 62.5%
+    case 5: left -= (left >> 2);              break;  // 75.0%
+    case 6: left -= (left >> 3);              break;  // 87.5%
+  //case 7:                                   break;  //100.0%
+  }
+  if(left_enable == false) left = 0;
+
+  sample = 0;
+  channels = 0;
+  if(channel1_right_enable) { sample += apu.square1.output; channels++; }
+  if(channel2_right_enable) { sample += apu.square2.output; channels++; }
+  if(channel3_right_enable) { sample +=    apu.wave.output; channels++; }
+  if(channel4_right_enable) { sample +=   apu.noise.output; channels++; }
+  if(channels) sample /= channels;
+  right = sclamp<16>(sample);
+
+  switch(right_volume) {
+    case 0: right >>= 3;                         break;  // 12.5%
+    case 1: right >>= 2;                         break;  // 25.0%
+    case 2: right = (right >> 2) + (right >> 3); break;  // 37.5%
+    case 3: right >>= 1;                         break;  // 50.0%
+    case 4: right = (right >> 1) + (right >> 3); break;  // 62.5%
+    case 5: right -= (right >> 2);               break;  // 75.0%
+    case 6: right -= (right >> 3);               break;  // 87.5%
+  //case 7:                                      break;  //100.0%
+  }
+  if(right_enable == false) right = 0;
+}
+
+void APU::Master::write(unsigned r, uint8 data) {
+  if(r == 0) {
+    left_enable  = data & 0x80;
+    left_volume  = (data >> 4) & 7;
+    right_enable = data & 0x08;
+    right_volume = (data >> 0) & 7;
+  }
+
+  if(r == 1) {
+    channel4_left_enable  = data & 0x80;
+    channel3_left_enable  = data & 0x40;
+    channel2_left_enable  = data & 0x20;
+    channel1_left_enable  = data & 0x10;
+    channel4_right_enable = data & 0x08;
+    channel3_right_enable = data & 0x04;
+    channel2_right_enable = data & 0x02;
+    channel1_right_enable = data & 0x01;
+  }
+
+  if(r == 2) {
+    enable = data & 0x80;
+  }
+}
+
+void APU::Master::power() {
+  left_enable = 0;
+  left_volume = 0;
+  right_enable = 0;
+  right_volume = 0;
+  channel4_left_enable  = 0;
+  channel3_left_enable  = 0;
+  channel2_left_enable  = 0;
+  channel1_left_enable  = 0;
+  channel4_right_enable = 0;
+  channel3_right_enable = 0;
+  channel2_right_enable = 0;
+  channel1_right_enable = 0;
+  enable = 0;
+
+  center = 0;
+  left   = 0;
+  right  = 0;
+}
+
+void APU::Master::serialize(serializer &s) {
+  s.integer(left_enable);
+  s.integer(left_volume);
+  s.integer(right_enable);
+  s.integer(right_volume);
+  s.integer(channel4_left_enable);
+  s.integer(channel3_left_enable);
+  s.integer(channel2_left_enable);
+  s.integer(channel1_left_enable);
+  s.integer(channel4_right_enable);
+  s.integer(channel3_right_enable);
+  s.integer(channel2_right_enable);
+  s.integer(channel1_right_enable);
+  s.integer(enable);
+
+  s.integer(center);
+  s.integer(left);
+  s.integer(right);
+}
+
+#endif

bsnes/gameboy/apu/master/master.hpp

@@ -0,0 +1,24 @@
+struct Master {
+  bool left_enable;
+  unsigned left_volume;
+  bool right_enable;
+  unsigned right_volume;
+  bool channel4_left_enable;
+  bool channel3_left_enable;
+  bool channel2_left_enable;
+  bool channel1_left_enable;
+  bool channel4_right_enable;
+  bool channel3_right_enable;
+  bool channel2_right_enable;
+  bool channel1_right_enable;
+  bool enable;
+
+  int16 center;
+  int16 left;
+  int16 right;
+
+  void run();
+  void write(unsigned r, uint8 data);
+  void power();
+  void serialize(serializer&);
+};

bsnes/gameboy/apu/noise/noise.cpp

@@ -0,0 +1,102 @@
+#ifdef APU_CPP
+
+void APU::Noise::run() {
+  if(period && --period == 0) {
+    period = divisor << frequency;
+    if(frequency < 14) {
+      bool bit = (lfsr ^ (lfsr >> 1)) & 1;
+      lfsr = (lfsr >> 1) ^ (bit << 14);
+      if(narrow_lfsr) lfsr |= (bit << 6);
+    }
+  }
+
+  uint4 sample = (lfsr & 1) ? 0 : volume;
+  if(counter && length == 0) sample = 0;
+
+  output = (sample * 4369) - 32768;
+}
+
+void APU::Noise::clock_length() {
+  if(counter && length) length--;
+}
+
+void APU::Noise::clock_envelope() {
+  if(envelope_period && --envelope_period == 0) {
+    envelope_period = envelope_frequency;
+    if(envelope_direction == 0 && volume >  0) volume--;
+    if(envelope_direction == 1 && volume < 15) volume++;
+  }
+}
+
+void APU::Noise::write(unsigned r, uint8 data) {
+  if(r == 1) {
+    initial_length = 64 - (data & 0x3f);
+
+    length = initial_length;
+  }
+
+  if(r == 2) {
+    envelope_volume = data >> 4;
+    envelope_direction = data & 0x08;
+    envelope_frequency = data & 0x07;
+  }
+
+  if(r == 3) {
+    frequency = data >> 4;
+    narrow_lfsr = data & 0x08;
+    divisor = (data & 0x07) << 4;
+    if(divisor == 0) divisor = 8;
+
+    period = divisor << frequency;
+  }
+
+  if(r == 4) {
+    bool initialize = data & 0x80;
+    counter = data & 0x40;
+
+    if(initialize) {
+      lfsr = ~0U;
+      length = initial_length;
+      envelope_period = envelope_frequency;
+      volume = envelope_volume;
+    }
+  }
+}
+
+void APU::Noise::power() {
+  initial_length = 0;
+  envelope_volume = 0;
+  envelope_direction = 0;
+  envelope_frequency = 0;
+  frequency = 0;
+  narrow_lfsr = 0;
+  divisor = 0;
+  counter = 0;
+
+  output = 0;
+  length = 0;
+  envelope_period = 0;
+  volume = 0;
+  period = 0;
+  lfsr = 0;
+}
+
+void APU::Noise::serialize(serializer &s) {
+  s.integer(initial_length);
+  s.integer(envelope_volume);
+  s.integer(envelope_direction);
+  s.integer(envelope_frequency);
+  s.integer(frequency);
+  s.integer(narrow_lfsr);
+  s.integer(divisor);
+  s.integer(counter);
+
+  s.integer(output);
+  s.integer(length);
+  s.integer(envelope_period);
+  s.integer(volume);
+  s.integer(period);
+  s.integer(lfsr);
+}
+
+#endif

bsnes/gameboy/apu/noise/noise.hpp

@@ -0,0 +1,24 @@
+struct Noise {
+  unsigned initial_length;
+  unsigned envelope_volume;
+  bool envelope_direction;
+  unsigned envelope_frequency;
+  unsigned frequency;
+  bool narrow_lfsr;
+  unsigned divisor;
+  bool counter;
+
+  int16 output;
+  unsigned length;
+  unsigned envelope_period;
+  unsigned volume;
+  unsigned period;
+  uint15 lfsr;
+
+  void run();
+  void clock_length();
+  void clock_envelope();
+  void write(unsigned r, uint8 data);
+  void power();
+  void serialize(serializer&);
+};

bsnes/gameboy/apu/serialization.cpp

@@ -0,0 +1,15 @@
+#ifdef APU_CPP
+
+void APU::serialize(serializer &s) {
+  s.array(mmio_data);
+  s.integer(sequencer_base);
+  s.integer(sequencer_step);
+
+  square1.serialize(s);
+  square2.serialize(s);
+  wave.serialize(s);
+  noise.serialize(s);
+  master.serialize(s);
+}
+
+#endif

bsnes/gameboy/apu/square1/square1.cpp

@@ -0,0 +1,146 @@
+#ifdef APU_CPP
+
+void APU::Square1::run() {
+  if(period && --period == 0) {
+    period = 4 * (2048 - frequency);
+    phase = (phase + 1) & 7;
+    switch(duty) {
+      case 0: duty_output = (phase == 6); break;  //______-_
+      case 1: duty_output = (phase >= 6); break;  //______--
+      case 2: duty_output = (phase >= 4); break;  //____----
+      case 3: duty_output = (phase <= 5); break;  //------__
+    }
+  }
+
+  uint4 sample = (duty_output ? volume : 0);
+  if(counter && length == 0) sample = 0;
+
+  output = (sample * 4369) - 32768;
+}
+
+void APU::Square1::sweep() {
+  if(enable == false) return;
+
+  signed offset = frequency_shadow >> sweep_shift;
+  if(sweep_direction) offset = -offset;
+  frequency_shadow += offset;
+
+  if(frequency_shadow < 0) {
+    frequency_shadow = 0;
+  } else if(frequency_shadow > 2047) {
+    frequency_shadow = 2048;
+    enable = false;
+  }
+
+  if(frequency_shadow <= 2047 && sweep_shift) {
+    frequency = frequency_shadow;
+    period = 4 * (2048 - frequency);
+  }
+}
+
+void APU::Square1::clock_length() {
+  if(counter && length) length--;
+}
+
+void APU::Square1::clock_sweep() {
+  if(sweep_frequency && sweep_period && --sweep_period == 0) {
+    sweep_period = sweep_frequency;
+    sweep();
+  }
+}
+
+void APU::Square1::clock_envelope() {
+  if(envelope_period && --envelope_period == 0) {
+    envelope_period = envelope_frequency;
+    if(envelope_direction == 0 && volume >  0) volume--;
+    if(envelope_direction == 1 && volume < 15) volume++;
+  }
+}
+
+void APU::Square1::write(unsigned r, uint8 data) {
+  if(r == 0) {
+    sweep_frequency = (data >> 4) & 7;
+    sweep_direction = data & 0x08;
+    sweep_shift = data & 0x07;
+  }
+
+  if(r == 1) {
+    duty = data >> 6;
+    length = data & 0x3f;
+  }
+
+  if(r == 2) {
+    envelope_volume = data >> 4;
+    envelope_direction = data & 0x08;
+    envelope_frequency = data & 0x07;
+  }
+
+  if(r == 3) {
+    frequency = (frequency & 0x0700) | data;
+  }
+
+  if(r == 4) {
+    bool initialize = data & 0x80;
+    counter = data & 0x40;
+    frequency = ((data & 7) << 8) | (frequency & 0x00ff);
+
+    if(initialize) {
+      envelope_period = envelope_frequency;
+      volume = envelope_volume;
+      frequency_shadow = frequency;
+      sweep_period = sweep_frequency;
+      enable = sweep_period || sweep_shift;
+      if(sweep_shift) sweep();
+    }
+  }
+
+  period = 4 * (2048 - frequency);
+}
+
+void APU::Square1::power() {
+  sweep_frequency = 0;
+  sweep_direction = 0;
+  sweep_shift = 0;
+  duty = 0;
+  length = 0;
+  envelope_volume = 0;
+  envelope_direction = 0;
+  envelope_frequency = 0;
+  frequency = 0;
+  counter = 0;
+
+  output = 0;
+  duty_output = 0;
+  phase = 0;
+  period = 0;
+  envelope_period = 0;
+  sweep_period = 0;
+  frequency_shadow = 0;
+  enable = 0;
+  volume = 0;
+}
+
+void APU::Square1::serialize(serializer &s) {
+  s.integer(sweep_frequency);
+  s.integer(sweep_direction);
+  s.integer(sweep_shift);
+  s.integer(duty);
+  s.integer(length);
+  s.integer(envelope_volume);
+  s.integer(envelope_direction);
+  s.integer(envelope_frequency);
+  s.integer(frequency);
+  s.integer(counter);
+
+  s.integer(output);
+  s.integer(duty_output);
+  s.integer(phase);
+  s.integer(period);
+  s.integer(envelope_period);
+  s.integer(sweep_period);
+  s.integer(frequency_shadow);
+  s.integer(enable);
+  s.integer(volume);
+}
+
+#endif

bsnes/gameboy/apu/square1/square1.hpp

@@ -0,0 +1,31 @@
+struct Square1 {
+  unsigned sweep_frequency;
+  unsigned sweep_direction;
+  unsigned sweep_shift;
+  unsigned duty;
+  unsigned length;
+  unsigned envelope_volume;
+  unsigned envelope_direction;
+  unsigned envelope_frequency;
+  unsigned frequency;
+  unsigned counter;
+
+  int16 output;
+  bool duty_output;
+  unsigned phase;
+  unsigned period;
+  unsigned envelope_period;
+  unsigned sweep_period;
+  signed frequency_shadow;
+  bool enable;
+  unsigned volume;
+
+  void run();
+  void sweep();
+  void clock_length();
+  void clock_sweep();
+  void clock_envelope();
+  void write(unsigned r, uint8 data);
+  void power();
+  void serialize(serializer&);
+};

bsnes/gameboy/apu/square2/square2.cpp

@@ -0,0 +1,97 @@
+#ifdef APU_CPP
+
+void APU::Square2::run() {
+  if(period && --period == 0) {
+    period = 4 * (2048 - frequency);
+    phase = (phase + 1) & 7;
+    switch(duty) {
+      case 0: duty_output = (phase == 6); break;  //______-_
+      case 1: duty_output = (phase >= 6); break;  //______--
+      case 2: duty_output = (phase >= 4); break;  //____----
+      case 3: duty_output = (phase <= 5); break;  //------__
+    }
+  }
+
+  uint4 sample = (duty_output ? volume : 0);
+  if(counter && length == 0) sample = 0;
+
+  output = (sample * 4369) - 32768;
+}
+
+void APU::Square2::clock_length() {
+  if(counter && length) length--;
+}
+
+void APU::Square2::clock_envelope() {
+  if(envelope_period && --envelope_period == 0) {
+    envelope_period = envelope_frequency;
+    if(envelope_direction == 0 && volume >  0) volume--;
+    if(envelope_direction == 1 && volume < 15) volume++;
+  }
+}
+
+void APU::Square2::write(unsigned r, uint8 data) {
+  if(r == 1) {
+    duty = data >> 6;
+    length = data & 0x3f;
+  }
+
+  if(r == 2) {
+    envelope_volume = data >> 4;
+    envelope_direction = data & 0x08;
+    envelope_frequency = data & 0x07;
+  }
+
+  if(r == 3) {
+    frequency = (frequency & 0x0700) | data;
+  }
+
+  if(r == 4) {
+    bool initialize = data & 0x80;
+    counter = data & 0x40;
+    frequency = ((data & 7) << 8) | (frequency & 0x00ff);
+
+    if(initialize) {
+      envelope_period = envelope_frequency;
+      volume = envelope_volume;
+    }
+  }
+
+  period = 4 * (2048 - frequency);
+}
+
+void APU::Square2::power() {
+  duty = 0;
+  length = 0;
+  envelope_volume = 0;
+  envelope_direction = 0;
+  envelope_frequency = 0;
+  frequency = 0;
+  counter = 0;
+
+  output = 0;
+  duty_output = 0;
+  phase = 0;
+  period = 0;
+  envelope_period = 0;
+  volume = 0;
+}
+
+void APU::Square2::serialize(serializer &s) {
+  s.integer(duty);
+  s.integer(length);
+  s.integer(envelope_volume);
+  s.integer(envelope_direction);
+  s.integer(envelope_frequency);
+  s.integer(frequency);
+  s.integer(counter);
+
+  s.integer(output);
+  s.integer(duty_output);
+  s.integer(phase);
+  s.integer(period);
+  s.integer(envelope_period);
+  s.integer(volume);
+}
+
+#endif

bsnes/gameboy/apu/square2/square2.hpp

@@ -0,0 +1,23 @@
+struct Square2 {
+  unsigned duty;
+  unsigned length;
+  unsigned envelope_volume;
+  unsigned envelope_direction;
+  unsigned envelope_frequency;
+  unsigned frequency;
+  unsigned counter;
+
+  int16 output;
+  bool duty_output;
+  unsigned phase;
+  unsigned period;
+  unsigned envelope_period;
+  unsigned volume;
+
+  void run();
+  void clock_length();
+  void clock_envelope();
+  void write(unsigned r, uint8 data);
+  void power();
+  void serialize(serializer&);
+};

bsnes/gameboy/apu/wave/wave.cpp

@@ -0,0 +1,103 @@
+#ifdef APU_CPP
+
+void APU::Wave::run() {
+  if(period && --period == 0) {
+    period = 2 * (2048 - frequency);
+    pattern_offset = (pattern_offset + 1) & 31;
+    pattern_sample = pattern[pattern_offset];
+  }
+
+  uint4 sample = pattern_sample;
+  if(counter && length == 0) sample = 0;
+  if(enable == false) sample = 0;
+
+  output = (sample * 4369) - 32768;
+  output >>= volume;
+}
+
+void APU::Wave::clock_length() {
+  if(counter && length) length--;
+}
+
+void APU::Wave::write(unsigned r, uint8 data) {
+  if(r == 0) {
+    dac_enable = data & 0x80;
+
+    if(dac_enable == false) enable = false;
+  }
+
+  if(r == 1) {
+    initial_length = 256 - data;
+
+    length = initial_length;
+  }
+
+  if(r == 2) {
+    switch((data >> 5) & 3) {
+      case 0: volume = 16; break;  //  0%
+      case 1: volume =  0; break;  //100%
+      case 2: volume =  1; break;  // 50%
+      case 3: volume =  2; break;  // 25%
+    }
+  }
+
+  if(r == 3) {
+    frequency = (frequency & 0x0700) | data;
+  }
+
+  if(r == 4) {
+    bool initialize = data & 0x80;
+    counter = data & 0x40;
+    frequency = ((data & 7) << 8) | (frequency & 0x00ff);
+
+    if(initialize && dac_enable) {
+      enable = true;
+      pattern_offset = 0;
+      length = initial_length;
+    }
+  }
+
+  period = 2 * (2048 - frequency);
+}
+
+void APU::Wave::write_pattern(unsigned p, uint8 data) {
+  p <<= 1;
+  pattern[p + 0] = (data >> 4) & 15;
+  pattern[p + 1] = (data >> 0) & 15;
+}
+
+void APU::Wave::power() {
+  dac_enable = 0;
+  initial_length = 0;
+  volume = 0;
+  frequency = 0;
+  counter = 0;
+
+  random_lfsr r;
+  foreach(n, pattern) n = r() & 15;
+
+  output = 0;
+  enable = 0;
+  length = 0;
+  period = 0;
+  pattern_offset = 0;
+  pattern_sample = 0;
+}
+
+void APU::Wave::serialize(serializer &s) {
+  s.integer(dac_enable);
+  s.integer(initial_length);
+  s.integer(volume);
+  s.integer(frequency);
+  s.integer(counter);
+  s.array(pattern);
+
+  s.integer(output);
+  s.integer(enable);
+  s.integer(length);
+  s.integer(period);
+  s.integer(pattern_offset);
+  s.integer(pattern_sample);
+}
+
+#endif

bsnes/gameboy/apu/wave/wave.hpp

@@ -0,0 +1,22 @@
+struct Wave {
+  bool dac_enable;
+  unsigned initial_length;
+  unsigned volume;
+  unsigned frequency;
+  bool counter;
+  uint8 pattern[32];
+
+  int16 output;
+  bool enable;
+  unsigned length;
+  unsigned period;
+  unsigned pattern_offset;
+  unsigned pattern_sample;
+
+  void run();
+  void clock_length();
+  void write(unsigned r, uint8 data);
+  void write_pattern(unsigned p, uint8 data);
+  void power();
+  void serialize(serializer&);
+};

bsnes/gameboy/cartridge/cartridge.cpp

@@ -0,0 +1,156 @@
+#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);
+          }
+        }
+      }
+    }
+  }
+
+  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;
+  }
+
+  ramdata = new uint8_t[ramsize = info.ramsize]();
+  system.load();
+  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;
+}
+
+uint8 Cartridge::mmio_read(uint16 addr) {
+  if(bootrom_enable && within<0x0000, 0x00ff>(addr)) return System::BootROM::sgb[addr];
+  return mapper->mmio_read(addr);
+}
+
+void Cartridge::mmio_write(uint16 addr, uint8 data) {
+  if(bootrom_enable && addr == 0xff50) bootrom_enable = false;
+  mapper->mmio_write(addr, data);
+}
+
+void Cartridge::power() {
+  bootrom_enable = true;
+
+  mbc0.power();
+  mbc1.power();
+  mbc2.power();
+  mbc3.power();
+  mbc5.power();
+  mmm01.power();
+  huc1.power();
+  huc3.power();
+
+  for(unsigned n = 0x0000; n <= 0x7fff; n++) bus.mmio[n] = this;
+  for(unsigned n = 0xa000; n <= 0xbfff; n++) bus.mmio[n] = this;
+  bus.mmio[0xff50] = this;
+}
+
+Cartridge::Cartridge() {
+  loaded = false;
+  romdata = 0;
+  ramdata = 0;
+}
+
+Cartridge::~Cartridge() {
+  unload();
+}
+
+}

bsnes/gameboy/cartridge/cartridge.hpp

@@ -0,0 +1,65 @@
+struct Cartridge : MMIO, 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;
+
+  MMIO *mapper;
+  bool bootrom_enable;
+
+  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);
+
+  uint8 mmio_read(uint16 addr);
+  void mmio_write(uint16 addr, uint8 data);
+
+  void power();
+
+  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,53 @@
+#ifdef CARTRIDGE_CPP
+
+void Cartridge::serialize(serializer &s) {
+  if(info.battery) s.array(ramdata, ramsize);
+  s.integer(bootrom_enable);
+
+  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,156 @@
+#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, 4194304);
+
+  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.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,78 @@
+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;
+
+    //$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,56 @@
+#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.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,82 @@
+//4194304hz (4 * 1024 * 1024)
+
+//70224 clocks/frame
+//  456 clocks/scanline
+//  154 scanlines/frame
+
+#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 >= 4194304) {
+    status.clock -= 4194304;
+    cartridge.mbc3.second();
+  }
+
+  //4194304 / N(hz) - 1 = mask
+  if((status.clock &   15) == 0) timer_262144hz();
+  if((status.clock &   63) == 0)  timer_65536hz();
+  if((status.clock &  255) == 0)  timer_16384hz();
+  if((status.clock &  511) == 0)   timer_8192hz();
+  if((status.clock & 1023) == 0)   timer_4096hz();
+
+  lcd.clock -= clocks;
+  if(lcd.clock <= 0) co_switch(scheduler.active_thread = lcd.thread);
+
+  apu.clock -= clocks;
+  if(apu.clock <= 0) co_switch(scheduler.active_thread = apu.thread);
+}
+
+void CPU::timer_262144hz() {
+  if(status.timer_enable && status.timer_clock == 1) {
+    if(++status.tima == 0) {
+      status.tima = status.tma;
+      interrupt_raise(Interrupt::Timer);
+    }
+  }
+}
+
+void CPU::timer_65536hz() {
+  if(status.timer_enable && status.timer_clock == 2) {
+    if(++status.tima == 0) {
+      status.tima = status.tma;
+      interrupt_raise(Interrupt::Timer);
+    }
+  }
+}
+
+void CPU::timer_16384hz() {
+  if(status.timer_enable && status.timer_clock == 3) {
+    if(++status.tima == 0) {
+      status.tima = status.tma;
+      interrupt_raise(Interrupt::Timer);
+    }
+  }
+
+  status.div++;
+}
+
+void CPU::timer_8192hz() {
+  if(status.serial_transfer && status.serial_clock) {
+    if(--status.serial_bits == 0) {
+      status.serial_transfer = 0;
+      interrupt_raise(Interrupt::Serial);
+    }
+  }
+}
+
+void CPU::timer_4096hz() {
+  if(status.timer_enable && status.timer_clock == 0) {
+    if(++status.tima == 0) {
+      status.tima = status.tma;
+      interrupt_raise(Interrupt::Timer);
+    }
+  }
+}
+
+#endif

bsnes/gameboy/cpu/timing/timing.hpp

@@ -0,0 +1,11 @@
+void add_clocks(unsigned clocks);
+void timer_262144hz();
+void timer_65536hz();
+void timer_16384hz();
+void timer_8192hz();
+void timer_4096hz();
+
+//opcode.cpp
+void op_io();
+uint8 op_read(uint16 addr);
+void op_write(uint16 addr, uint8 data);

bsnes/gameboy/gameboy.hpp

@@ -0,0 +1,96 @@
+//bgameboy
+//author: byuu
+//project started: 2010-12-27
+
+namespace GameBoy {
+  namespace Info {
+    static const char Name[] = "bgameboy";
+    static const char Version[] = "000.19";
+    static unsigned SerializerVersion = 1;
+  }
+}
+
+#include <libco/libco.h>
+
+#include <nall/foreach.hpp>
+#include <nall/platform.hpp>
+#include <nall/property.hpp>
+#include <nall/random.hpp>
+#include <nall/serializer.hpp>
+#include <nall/stdint.hpp>
+#include <nall/string.hpp>
+#include <nall/varint.hpp>
+using namespace nall;
+
+namespace GameBoy {
+  typedef int8_t  int8;
+  typedef int16_t int16;
+  typedef int32_t int32;
+  typedef int64_t int64;
+
+  typedef uint8_t  uint8;
+  typedef uint16_t uint16;
+  typedef uint32_t uint32;
+  typedef uint64_t uint64;
+
+  typedef uint_t< 1> uint1;
+  typedef uint_t< 2> uint2;
+  typedef uint_t< 3> uint3;
+  typedef uint_t< 4> uint4;
+  typedef uint_t< 5> uint5;
+  typedef uint_t< 6> uint6;
+  typedef uint_t< 7> uint7;
+
+  typedef uint_t< 9> uint9;
+  typedef uint_t<10> uint10;
+  typedef uint_t<11> uint11;
+  typedef uint_t<12> uint12;
+  typedef uint_t<13> uint13;
+  typedef uint_t<14> uint14;
+  typedef uint_t<15> uint15;
+
+  typedef uint_t<17> uint17;
+  typedef uint_t<18> uint18;
+  typedef uint_t<19> uint19;
+  typedef uint_t<20> uint20;
+  typedef uint_t<21> uint21;
+  typedef uint_t<22> uint22;
+  typedef uint_t<23> uint23;
+  typedef uint_t<24> uint24;
+  typedef uint_t<25> uint25;
+  typedef uint_t<26> uint26;
+  typedef uint_t<27> uint27;
+  typedef uint_t<28> uint28;
+  typedef uint_t<29> uint29;
+  typedef uint_t<30> uint30;
+  typedef uint_t<31> uint31;
+
+  template<uint16 lo, uint16 hi>
+  alwaysinline bool within(uint16 addr) {
+    static const uint16 mask = ~(hi ^ lo);
+    return (addr & mask) == lo;
+  }
+
+  struct Processor {
+    cothread_t thread;
+    unsigned frequency;
+    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,12 @@
+class Interface {
+public:
+  virtual void lcd_scanline() {}
+  virtual void joyp_write(bool p15, bool p14) {}
+
+  virtual void video_refresh(const uint8_t *data) {}
+  virtual void audio_sample(int16_t center, int16_t left, int16_t 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,239 @@
+#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();
+
+  clock += clocks;
+  if(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;
+  system.interface->lcd_scanline();
+}
+
+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, 4194304);
+
+  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 = 0x0000; n <= 0xffff; 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,55 @@
+#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) {
+    }
+  }
+}
+
+void System::init(Interface *interface_) {
+  interface = interface_;
+}
+
+void System::load() {
+  serialize_init();
+}
+
+void System::power() {
+  bus.power();
+  cartridge.power();
+  cpu.power();
+  apu.power();
+  lcd.power();
+  scheduler.init();
+
+  clocks_executed = 0;
+}
+
+}

bsnes/gameboy/system/system.hpp

@@ -0,0 +1,37 @@
+class Interface;
+
+enum class Input : unsigned {
+  Up, Down, Left, Right, B, A, Select, Start,
+};
+
+struct System {
+  struct BootROM {
+    static const uint8 dmg[256];
+    static const uint8 sgb[256];
+  } bootROM;
+
+  void run();
+  void runtosave();
+  void runthreadtosave();
+
+  void init(Interface*);
+  void load();
+  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/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.cfg");
-  unused = userpath(path);
-  if(!strend(path, "/") && !strend(path, "\\")) strcat(path, "/");
-  string userPath = string(path, ".bsnes/bsnes.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/libco/libco.c

@@ -8,8 +8,8 @@
   #include "x86.c"
 #elif defined(__GNUC__) && defined(__amd64__)
   #include "amd64.c"
-#elif defined(__GNUC__) && defined(__powerpc__) && defined(__ELF__)
-  #include "ppc-elf.c"
+#elif defined(__GNUC__) && defined(_ARCH_PPC)
+  #include "ppc.c"
 #elif defined(__GNUC__)
   #include "sjlj.c"
 #elif defined(_MSC_VER) && defined(_M_IX86)

bsnes/libco/libco.h

@@ -1,6 +1,6 @@
 /*
   libco
-  version: 0.15 (2009-10-12)
+  version: 0.16 (2010-12-24)
   license: public domain
 */
 

bsnes/libco/ppc-elf.c

@@ -1,325 +0,0 @@
-/*
- * libco.ppc-elf
- * author: Kernigh
- * license: public domain
- *
- * PowerPC 32-bit ELF implementation of libco (for compile with GCC),
- * ported from PowerPC Mac OS X implementation (ppc.s) by Vas Crabb.
- * This ELF version works for OpenBSD, and might also work for FreeBSD,
- * NetBSD and Linux.
- *
- * Note 1:	This implementation does not handle the AltiVec/VMX
- *		registers, because the ELF ABI does not mention them,
- *		and my OpenBSD system is not using them.
- *
- * Note 2:	If you want position-independent code, then you must
- *		define __PIC__. gcc -fpic or -fPIC defines __PIC__, but
- *		gcc -fpie or -fPIE might not. If you want to use -fpie
- *		or -fPIE, then you might need a manual definition:
- *			gcc -fpie -D__PIC__=1
- *			gcc -fPIE -D__PIC__=2
- *
- * The ELF ABI is "System V Application Binary Interface, PowerPC
- * Processor Supplement", which you can get from
- *   <http://refspecs.linux-foundation.org/elf/elfspec_ppc.pdf>
- * (PDF file, hosted by Linux Foundation).
- *
- * ELF and Mac OS X use similar conventions to allocate the registers,
- * and to pass arguments and return values through registers. The main
- * differences are that ELF has a slightly different stack format, that
- * symbols are different (and without an extra underscore at the start),
- * and that the assembly syntax is different.
- *
- * A function may destroy the values of volatile registers, but must
- * preserve the values of nonvolatile registers. So the co_switch()
- * function only saves the nonvolatile registers.
- *
- * [nonvolatile registers in ELF]
- *   %r1, %r14..%r31
- *   %f14..%f31
- *   %cr2..%cr4 in cr
- *
- * [volatile registers in ELF]
- *   %r0, %r3..%r10
- *   %f0..%f13
- *   %cr0, %cr1, %cr5..%cr7 in cr
- *   ctr, lr, xer
- *
- * lr (link register) is volatile, but it contains the return address,
- * so co_switch must save lr.
- *
- * %r13 is the small data pointer. This is constant across threads, so
- * co_switch() does not touch %r13.
- *
- * %r2 is a reserved register, so co_switch() does not touch %r2. Some
- * systems might borrow an idea from the PowerPC Embedded ABI, and might
- * use %r2 as a small read-only data pointer, which is constant across
- * threads.
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void * cothread_t;
-
-/*
- * co_active_context is either in a global offset table (if we are
- * compiling -fPIC or -fPIE) or has an absolute position.
- */
-static void *co_main_stack_pointer;
-static cothread_t co_active_context = &co_main_stack_pointer;
-
-extern cothread_t co_active() {
-  return co_active_context;
-}
-
-/*
- * Embedded assembly.
- *
- * We are not using the percent-sign substitution feature,
- * so we must write "%r1", not "%%r1".
- *
- * We always write 'bl malloc@plt', not 'bl malloc'. The '@plt'
- * is necessary in position-indepent code and seems to have no
- * significant effect in fixed-position code.
- *
- * We never use the 'lmw' or 'stmw' instructions. The ELF ABI
- * mentions that these instructions "are usually slower than
- * a sequence of other instructions that have the same effect."
- * We instead use sequences of 'lwz' or 'stz' instructions.
- */
-__asm__("\n"
-"### embedded assembly						\n"
-".section \".text\"						\n"
-"	.balign	4						\n"
-"								\n"
-/*
- * void co_switch(co_thread to %r3)
- *
- * Allocate our stack frame of 240 bytes:
- * Old      New        Value
- *  4(%r1)   244(%r1)   return address, used by us
- *  0(%r1)   240(%r1)   frame pointer
- *           232(%r1)   %f31
- *           224(%r1)   %f30
- *                      ...
- *            96(%r1)   %f14
- *            92(%r1)   %r31
- *            88(%r1)   %r30
- *                      ...
- *            24(%r1)   %r14
- *            20(%r1)   condition register
- *             8(%r1)   padding of 12 bytes
- *             4(%r1)   return address, never used
- *             0(%r1)   frame pointer
- *
- * Save our registers in our stack frame.
- * Save our stack pointer in 0(%r4).
- * Switch to the stack of the other thread.
- * Restore registers and return.
- */
-"	.globl	co_switch					\n"
-"	.type	co_switch, @function				\n"
-"co_switch:							\n"
-"	mflr	%r0		# %r0 = return address		\n"
-"	mfcr	%r9		# %r9 = condition register	\n"
-"	stwu	%r1, -240(%r1)	# allocate stack frame		\n"
-"								\n"
-"	stw	%r0, 244(%r1)	# save return address		\n"
-"	stfd	%f31, 232(%r1)	# save floating-point regs	\n"
-"	stfd	%f30, 224(%r1)					\n"
-"	stfd	%f29, 216(%r1)					\n"
-"	stfd	%f28, 208(%r1)					\n"
-"	stfd	%f27, 200(%r1)					\n"
-"	stfd	%f26, 192(%r1)					\n"
-"	stfd	%f25, 184(%r1)					\n"
-"	stfd	%f24, 176(%r1)					\n"
-"	stfd	%f23, 168(%r1)					\n"
-"	stfd	%f22, 160(%r1)					\n"
-"	stfd	%f21, 152(%r1)					\n"
-"	stfd	%f20, 144(%r1)					\n"
-"	stfd	%f19, 136(%r1)					\n"
-"	stfd	%f18, 128(%r1)					\n"
-"	stfd	%f17, 120(%r1)					\n"
-"	stfd	%f16, 112(%r1)					\n"
-"	stfd	%f16, 104(%r1)					\n"
-"	stfd	%f14, 96(%r1)					\n"
-"	stw	%r31, 92(%r1)	# save general-purpose regs	\n"
-"	stw	%r30, 88(%r1)					\n"
-"	stw	%r29, 84(%r1)					\n"
-"	stw	%r28, 80(%r1)					\n"
-"	stw	%r27, 76(%r1)					\n"
-"	stw	%r26, 72(%r1)					\n"
-"	stw	%r25, 68(%r1)					\n"
-"	stw	%r24, 64(%r1)					\n"
-"	stw	%r23, 60(%r1)					\n"
-"	stw	%r22, 56(%r1)					\n"
-"	stw	%r21, 52(%r1)					\n"
-"	stw	%r20, 48(%r1)					\n"
-"	stw	%r19, 44(%r1)					\n"
-"	stw	%r18, 40(%r1)					\n"
-"	stw	%r17, 36(%r1)					\n"
-"	stw	%r16, 32(%r1)					\n"
-"	stw	%r15, 28(%r1)					\n"
-"	stw	%r14, 24(%r1)					\n"
-"	stw	%r9, 20(%r1)	# save condition reg		\n"
-"								\n"
-"	# save current context, set new context			\n"
-"	#   %r4 = co_active_context				\n"
-"	#   co_active_context = %r3				\n"
-#if __PIC__ == 2
-"	# position-independent code, large model (-fPIC)	\n"
-"	bl	_GLOBAL_OFFSET_TABLE_@local-4			\n"
-"	mflr	%r8		# %r8 = address of got		\n"
-"	addis	%r7, %r8, co_active_context@got@ha		\n"
-"	lwz	%r6, co_active_context@got@l(%r7)		\n"
-"	lwz	%r4, 0(%r6)					\n"
-"	stw	%r3, 0(%r6)					\n"
-#elif __PIC__ == 1
-"	# position-independent code, small model (-fpic)	\n"
-"	bl	_GLOBAL_OFFSET_TABLE_@local-4			\n"
-"	mflr	%r8		# %r8 = address of got		\n"
-"	lwz	%r7, co_active_context@got(%r8)			\n"
-"	lwz	%r4, 0(%r7)					\n"
-"	stw	%r3, 0(%r7)					\n"
-#else
-"	# fixed-position code					\n"
-"	lis	%r8, co_active_context@ha			\n"
-"	lwz	%r4, co_active_context@l(%r8)			\n"
-"	stw	%r3, co_active_context@l(%r8)			\n"
-#endif
-"								\n"
-"	# save current stack pointer				\n"
-"	stw	%r1, 0(%r4)					\n"
-"	# get new stack pointer					\n"
-"	lwz	%r1, 0(%r3)					\n"
-"								\n"
-"	lwz	%r0, 244(%r1)	# get return address		\n"
-"	lfd	%f31, 232(%r1)	# restore floating-point regs	\n"
-"	lfd	%f30, 224(%r1)					\n"
-"	lfd	%f29, 216(%r1)					\n"
-"	lfd	%f28, 208(%r1)					\n"
-"	lfd	%f27, 200(%r1)					\n"
-"	lfd	%f26, 192(%r1)					\n"
-"	lfd	%f25, 184(%r1)					\n"
-"	lfd	%f24, 176(%r1)					\n"
-"	lfd	%f23, 168(%r1)					\n"
-"	lfd	%f22, 160(%r1)					\n"
-"	lfd	%f21, 152(%r1)					\n"
-"	lfd	%f20, 144(%r1)					\n"
-"	lfd	%f19, 136(%r1)					\n"
-"	lfd	%f18, 128(%r1)					\n"
-"	lfd	%f17, 120(%r1)					\n"
-"	lfd	%f16, 112(%r1)					\n"
-"	lfd	%f16, 104(%r1)					\n"
-"	lfd	%f14, 96(%r1)					\n"
-"	lwz	%r31, 92(%r1)	# restore general-purpose regs	\n"
-"	lwz	%r30, 88(%r1)					\n"
-"	lwz	%r29, 84(%r1)					\n"
-"	lwz	%r28, 80(%r1)					\n"
-"	lwz	%r27, 76(%r1)					\n"
-"	lwz	%r26, 72(%r1)					\n"
-"	lwz	%r25, 68(%r1)					\n"
-"	lwz	%r24, 64(%r1)					\n"
-"	lwz	%r23, 60(%r1)					\n"
-"	lwz	%r22, 56(%r1)					\n"
-"	lwz	%r21, 52(%r1)					\n"
-"	lwz	%r20, 48(%r1)					\n"
-"	lwz	%r19, 44(%r1)					\n"
-"	lwz	%r18, 40(%r1)					\n"
-"	lwz	%r17, 36(%r1)					\n"
-"	lwz	%r16, 32(%r1)					\n"
-"	lwz	%r15, 28(%r1)					\n"
-"	lwz	%r14, 24(%r1)					\n"
-"	lwz	%r9, 20(%r1)	# get condition reg		\n"
-"								\n"
-"	addi	%r1, %r1, 240	# free stack frame		\n"
-"	mtlr	%r0		# restore return address	\n"
-"	mtcr	%r9		# restore condition register	\n"
-"	blr			# return			\n"
-"	.size	co_switch, . - co_switch			\n"
-"								\n"
-/*
- * cothread_t %r3 co_create(unsigned int stack_size %r3,
- *			    void (*coentry %r4)())
- *
- * Allocate a new stack, such that when you co_switch to that
- * stack, then co_switch returns to coentry.
- */
-"	.globl	co_create					\n"
-"	.type	co_create, @function				\n"
-"co_create:							\n"
-"	mflr	%r0		# %r0 = return address		\n"
-"	stwu	%r1, -16(%r1)	# allocate my stack frame	\n"
-"	stw	%r0, 20(%r1)	# save return address		\n"
-"	stw	%r31, 12(%r1)	# save %r31			\n"
-"	stw	%r30, 8(%r1)	# save %r30			\n"
-"								\n"
-"	mr	%r30, %r3	# %r30 = stack_size		\n"
-"	mr	%r31, %r4	# %r31 = coentry		\n"
-"								\n"
-"	# Call malloc(stack_size %r3) to allocate stack;	\n"
-"	# malloc() probably uses good alignment.		\n"
-"	#							\n"
-"	bl	malloc@plt	# returns %r3 = low end		\n"
-"	cmpwi	%r3, 0		# if returned NULL,		\n"
-"	beq-	1f		#   then abort			\n"
-"								\n"
-"	# we return %r3 = low end of stack			\n"
-"	add	%r4, %r3, %r30	# %r4 = high end of stack	\n"
-"								\n"
-"	# uncomment if malloc() uses wrong alignment		\n"
-"	#rlwinm	%r4,%r4,0,0,27	# force 16-byte alignment 	\n"
-"								\n"
-	/*
-	 * Allocate two stack frames:
-	 *   16 bytes for stack frame with return address
-	 *  240 bytes for co_switch stack frame
-	 *
-	 * Old         New         Value
-	 *   -8(%r4)    248(%r5)    padding of 8 bytes
-	 *  -12(%r4)    244(%r5)    return address = coentry
-	 *  -16(%r4)    240(%r5)    frame pointer = NULL
-	 *              232(%r5)    %f31 = 0
-	 *                          ...
-	 *               20(%r5)    condition register = 0
-	 *                0(%r5)    frame pointer
-	 */
-"	li	%r9, (240-20)/4+1				\n"
-"	addi	%r5, %r4, -16	# allocate first stack frame	\n"
-"	li	%r0, 0						\n"
-"	stwu	%r5, -240(%r5)	# allocate second stack frame	\n"
-"	li	%r8, 20						\n"
-"	mtctr	%r9		# loop %r9 times		\n"
-"2:	# loop to store zero to 20(%r5) through 240(%r5)	\n"
-"	stwx	%r0, %r5, %r8					\n"
-"	addi	%r8, %r8, 4	# index += 4			\n"
-"	bdnz+	2b		# ctr -= 1, branch if nonzero	\n"
-"								\n"
-"	stw	%r31, 244(%r5)	# return address = coentry	\n"
-"	stw	%r5, 0(%r3)	# save stack pointer		\n"
-"								\n"
-"	lwz	%r0, 20(%r1)	# get return address		\n"
-"	lwz	%r31, 12(%r1)	# restore %r31			\n"
-"	lwz	%r30, 8(%r1)	# restore %r30			\n"
-"	mtlr	%r0		# restore return address	\n"
-"	addi	%r1, %r1, 16	# free stack frame		\n"
-"	blr			# return			\n"
-"								\n"
-"1:	b	abort@plt	# branch 1f to abort		\n"
-"	.size	co_create, . - co_create			\n"
-"								\n"
-/*
- * void co_delete(cothread_t) => void free(void *)
- */
-"	.globl	co_delete					\n"
-"	.type	co_delete, @function				\n"
-"co_delete:							\n"
-"	b	free@plt					\n"
-"								\n"
-);
-
-#ifdef __cplusplus
-}
-#endif

bsnes/libco/ppc.c

@@ -0,0 +1,407 @@
+/*
+  libco.ppc (2010-10-17)
+  author: blargg
+  license: public domain
+*/
+
+/* PowerPC 32/64 using embedded or external asm, with optional
+floating-point and AltiVec save/restore */
+
+#define LIBCO_C
+#include "libco.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#define LIBCO_MPROTECT (__unix__ && !LIBCO_PPC_ASM)
+
+#if LIBCO_MPROTECT
+	#include <unistd.h>
+	#include <sys/mman.h>
+#endif
+
+/* State format (offsets in 32-bit words)
+
++0	Pointer to swap code
+	Rest of function descriptor for entry function
++8	PC
++10	SP
+	Special regs
+	GPRs
+	FPRs
+	VRs
+	stack
+*/
+
+enum { state_size  = 1024 };
+enum { above_stack = 2048 };
+enum { stack_align = 256  };
+
+static thread_local cothread_t co_active_handle = 0;
+
+/**** Determine environment ****/
+
+#define LIBCO_PPC64 (_ARCH_PPC64 || __PPC64__ || __ppc64__ || __powerpc64__)
+
+/* Whether function calls are indirect through a descriptor,
+or are directly to function */
+#ifndef LIBCO_PPCDESC
+	#if !_CALL_SYSV && (_CALL_AIX || _CALL_AIXDESC || LIBCO_PPC64)
+		#define LIBCO_PPCDESC 1
+	#endif
+#endif
+
+#ifdef LIBCO_PPC_ASM
+
+	#ifdef __cplusplus
+		extern "C"
+	#endif
+	
+	/* Swap code is in ppc.S */
+	void co_swap_asm( cothread_t, cothread_t );
+	#define CO_SWAP_ASM( x, y ) co_swap_asm( x, y )
+
+#else
+
+/* Swap code is here in array. Please leave dieassembly comments,
+as they make it easy to see what it does, and reorder instructions
+if one wants to see whether that improves performance. */
+static const uint32_t libco_ppc_code [] = {
+#if LIBCO_PPC64
+    0x7d000026, /* mfcr    r8 */
+    0xf8240028, /* std     r1,40(r4) */
+    0x7d2802a6, /* mflr    r9 */
+    0xf9c40048, /* std     r14,72(r4) */
+    0xf9e40050, /* std     r15,80(r4) */
+    0xfa040058, /* std     r16,88(r4) */
+    0xfa240060, /* std     r17,96(r4) */
+    0xfa440068, /* std     r18,104(r4) */
+    0xfa640070, /* std     r19,112(r4) */
+    0xfa840078, /* std     r20,120(r4) */
+    0xfaa40080, /* std     r21,128(r4) */
+    0xfac40088, /* std     r22,136(r4) */
+    0xfae40090, /* std     r23,144(r4) */
+    0xfb040098, /* std     r24,152(r4) */
+    0xfb2400a0, /* std     r25,160(r4) */
+    0xfb4400a8, /* std     r26,168(r4) */
+    0xfb6400b0, /* std     r27,176(r4) */
+    0xfb8400b8, /* std     r28,184(r4) */
+    0xfba400c0, /* std     r29,192(r4) */
+    0xfbc400c8, /* std     r30,200(r4) */
+    0xfbe400d0, /* std     r31,208(r4) */
+    0xf9240020, /* std     r9,32(r4) */
+    0xe8e30020, /* ld      r7,32(r3) */
+    0xe8230028, /* ld      r1,40(r3) */
+    0x48000009, /* bl      1 */
+	0x7fe00008, /* trap */
+    0x91040030,/*1:stw     r8,48(r4) */
+    0x80c30030, /* lwz     r6,48(r3) */
+    0x7ce903a6, /* mtctr   r7 */
+    0xe9c30048, /* ld      r14,72(r3) */
+    0xe9e30050, /* ld      r15,80(r3) */
+    0xea030058, /* ld      r16,88(r3) */
+    0xea230060, /* ld      r17,96(r3) */
+    0xea430068, /* ld      r18,104(r3) */
+    0xea630070, /* ld      r19,112(r3) */
+    0xea830078, /* ld      r20,120(r3) */
+    0xeaa30080, /* ld      r21,128(r3) */
+    0xeac30088, /* ld      r22,136(r3) */
+    0xeae30090, /* ld      r23,144(r3) */
+    0xeb030098, /* ld      r24,152(r3) */
+    0xeb2300a0, /* ld      r25,160(r3) */
+    0xeb4300a8, /* ld      r26,168(r3) */
+    0xeb6300b0, /* ld      r27,176(r3) */
+    0xeb8300b8, /* ld      r28,184(r3) */
+    0xeba300c0, /* ld      r29,192(r3) */
+    0xebc300c8, /* ld      r30,200(r3) */
+    0xebe300d0, /* ld      r31,208(r3) */
+    0x7ccff120, /* mtcr    r6 */
+#else
+	0x7d000026, /* mfcr    r8 */
+	0x90240028, /* stw     r1,40(r4) */
+	0x7d2802a6, /* mflr    r9 */
+	0x91a4003c, /* stw     r13,60(r4) */
+	0x91c40040, /* stw     r14,64(r4) */
+	0x91e40044, /* stw     r15,68(r4) */
+	0x92040048, /* stw     r16,72(r4) */
+	0x9224004c, /* stw     r17,76(r4) */
+	0x92440050, /* stw     r18,80(r4) */
+	0x92640054, /* stw     r19,84(r4) */
+	0x92840058, /* stw     r20,88(r4) */
+	0x92a4005c, /* stw     r21,92(r4) */
+	0x92c40060, /* stw     r22,96(r4) */
+	0x92e40064, /* stw     r23,100(r4) */
+	0x93040068, /* stw     r24,104(r4) */
+	0x9324006c, /* stw     r25,108(r4) */
+	0x93440070, /* stw     r26,112(r4) */
+	0x93640074, /* stw     r27,116(r4) */
+	0x93840078, /* stw     r28,120(r4) */
+	0x93a4007c, /* stw     r29,124(r4) */
+	0x93c40080, /* stw     r30,128(r4) */
+	0x93e40084, /* stw     r31,132(r4) */
+	0x91240020, /* stw     r9,32(r4) */
+	0x80e30020, /* lwz     r7,32(r3) */
+	0x80230028, /* lwz     r1,40(r3) */
+	0x48000009, /* bl      1 */
+	0x7fe00008, /* trap */
+	0x91040030,/*1:stw     r8,48(r4) */
+	0x80c30030, /* lwz     r6,48(r3) */
+	0x7ce903a6, /* mtctr   r7 */
+	0x81a3003c, /* lwz     r13,60(r3) */
+	0x81c30040, /* lwz     r14,64(r3) */
+	0x81e30044, /* lwz     r15,68(r3) */
+	0x82030048, /* lwz     r16,72(r3) */
+	0x8223004c, /* lwz     r17,76(r3) */
+	0x82430050, /* lwz     r18,80(r3) */
+	0x82630054, /* lwz     r19,84(r3) */
+	0x82830058, /* lwz     r20,88(r3) */
+	0x82a3005c, /* lwz     r21,92(r3) */
+	0x82c30060, /* lwz     r22,96(r3) */
+	0x82e30064, /* lwz     r23,100(r3) */
+	0x83030068, /* lwz     r24,104(r3) */
+	0x8323006c, /* lwz     r25,108(r3) */
+	0x83430070, /* lwz     r26,112(r3) */
+	0x83630074, /* lwz     r27,116(r3) */
+	0x83830078, /* lwz     r28,120(r3) */
+	0x83a3007c, /* lwz     r29,124(r3) */
+	0x83c30080, /* lwz     r30,128(r3) */
+	0x83e30084, /* lwz     r31,132(r3) */
+	0x7ccff120, /* mtcr    r6 */
+#endif
+
+#ifndef LIBCO_PPC_NOFP
+	0xd9c400e0, /* stfd    f14,224(r4) */
+	0xd9e400e8, /* stfd    f15,232(r4) */
+	0xda0400f0, /* stfd    f16,240(r4) */
+	0xda2400f8, /* stfd    f17,248(r4) */
+	0xda440100, /* stfd    f18,256(r4) */
+	0xda640108, /* stfd    f19,264(r4) */
+	0xda840110, /* stfd    f20,272(r4) */
+	0xdaa40118, /* stfd    f21,280(r4) */
+	0xdac40120, /* stfd    f22,288(r4) */
+	0xdae40128, /* stfd    f23,296(r4) */
+	0xdb040130, /* stfd    f24,304(r4) */
+	0xdb240138, /* stfd    f25,312(r4) */
+	0xdb440140, /* stfd    f26,320(r4) */
+	0xdb640148, /* stfd    f27,328(r4) */
+	0xdb840150, /* stfd    f28,336(r4) */
+	0xdba40158, /* stfd    f29,344(r4) */
+	0xdbc40160, /* stfd    f30,352(r4) */
+	0xdbe40168, /* stfd    f31,360(r4) */
+	0xc9c300e0, /* lfd     f14,224(r3) */
+	0xc9e300e8, /* lfd     f15,232(r3) */
+	0xca0300f0, /* lfd     f16,240(r3) */
+	0xca2300f8, /* lfd     f17,248(r3) */
+	0xca430100, /* lfd     f18,256(r3) */
+	0xca630108, /* lfd     f19,264(r3) */
+	0xca830110, /* lfd     f20,272(r3) */
+	0xcaa30118, /* lfd     f21,280(r3) */
+	0xcac30120, /* lfd     f22,288(r3) */
+	0xcae30128, /* lfd     f23,296(r3) */
+	0xcb030130, /* lfd     f24,304(r3) */
+	0xcb230138, /* lfd     f25,312(r3) */
+	0xcb430140, /* lfd     f26,320(r3) */
+	0xcb630148, /* lfd     f27,328(r3) */
+	0xcb830150, /* lfd     f28,336(r3) */
+	0xcba30158, /* lfd     f29,344(r3) */
+	0xcbc30160, /* lfd     f30,352(r3) */
+	0xcbe30168, /* lfd     f31,360(r3) */
+#endif
+
+#ifdef __ALTIVEC__
+	0x7ca042a6, /* mfvrsave r5 */
+	0x39040180, /* addi    r8,r4,384 */
+	0x39240190, /* addi    r9,r4,400 */
+	0x70a00fff, /* andi.   r0,r5,4095 */
+	0x90a40034, /* stw     r5,52(r4) */
+	0x4182005c, /* beq-    2 */
+	0x7e8041ce, /* stvx    v20,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7ea049ce, /* stvx    v21,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7ec041ce, /* stvx    v22,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7ee049ce, /* stvx    v23,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f0041ce, /* stvx    v24,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7f2049ce, /* stvx    v25,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f4041ce, /* stvx    v26,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7f6049ce, /* stvx    v27,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f8041ce, /* stvx    v28,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7fa049ce, /* stvx    v29,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7fc041ce, /* stvx    v30,r0,r8 */
+	0x7fe049ce, /* stvx    v31,r0,r9 */
+	0x80a30034,/*2:lwz     r5,52(r3) */
+	0x39030180, /* addi    r8,r3,384 */
+	0x39230190, /* addi    r9,r3,400 */
+	0x70a00fff, /* andi.   r0,r5,4095 */
+	0x7ca043a6, /* mtvrsave r5 */
+	0x4d820420, /* beqctr   */
+	0x7e8040ce, /* lvx     v20,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7ea048ce, /* lvx     v21,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7ec040ce, /* lvx     v22,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7ee048ce, /* lvx     v23,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f0040ce, /* lvx     v24,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7f2048ce, /* lvx     v25,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f4040ce, /* lvx     v26,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7f6048ce, /* lvx     v27,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f8040ce, /* lvx     v28,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7fa048ce, /* lvx     v29,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7fc040ce, /* lvx     v30,r0,r8 */
+	0x7fe048ce, /* lvx     v31,r0,r9 */
+#endif
+
+	0x4e800420, /* bctr */
+};
+
+	#if LIBCO_PPCDESC
+		/* Function call goes through indirect descriptor */
+		#define CO_SWAP_ASM( x, y ) \
+			((void (*)( cothread_t, cothread_t )) (uintptr_t) x)( x, y )
+	#else
+		/* Function call goes directly to code */
+		#define CO_SWAP_ASM( x, y ) \
+			((void (*)( cothread_t, cothread_t )) (uintptr_t) libco_ppc_code)( x, y )
+	#endif
+
+#endif
+
+static uint32_t* co_create_( unsigned size, uintptr_t entry )
+{
+	uint32_t* t = (uint32_t*) malloc( size );
+	
+	(void) entry;
+	
+	#if LIBCO_PPCDESC
+		if ( t )
+		{
+			/* Copy entry's descriptor */
+			memcpy( t, (void*) entry, sizeof (void*) * 3 );
+			
+			/* Set function pointer to swap routine */
+			#ifdef LIBCO_PPC_ASM
+				*(const void**) t = *(void**) &co_swap_asm;
+			#else
+				*(const void**) t = libco_ppc_code;
+			#endif
+		}
+	#endif
+	
+	return t;
+}
+
+cothread_t co_create( unsigned int size, void (*entry_)( void ) )
+{
+	uintptr_t entry = (uintptr_t) entry_;
+	uint32_t* t = NULL;
+	
+	/* Be sure main thread was successfully allocated */
+	if ( co_active() )
+	{
+		size += state_size + above_stack + stack_align;
+		t = co_create_( size, entry );
+	}
+	
+	if ( t )
+	{
+		uintptr_t sp;
+		int shift;
+		
+		/* Save current registers into new thread, so that any special ones will
+		have proper values when thread is begun */
+		CO_SWAP_ASM( t, t );
+		
+		#if LIBCO_PPCDESC
+			/* Get real address */
+			entry = (uintptr_t) *(void**) entry;
+		#endif
+		
+		/* Put stack near end of block, and align */
+		sp = (uintptr_t) t + size - above_stack;
+		sp -= sp % stack_align;
+		
+		/* On PPC32, we save and restore GPRs as 32 bits. For PPC64, we
+		save and restore them as 64 bits, regardless of the size the ABI
+		uses. So, we manually write pointers at the proper size. We always
+		save and restore at the same address, and since PPC is big-endian,
+		we must put the low byte first on PPC32. */
+		
+		/* If uintptr_t is 32 bits, >>32 is undefined behavior, so we do two shifts
+		and don't have to care how many bits uintptr_t is. */
+		#if LIBCO_PPC64
+			shift = 16;
+		#else
+			shift = 0;
+		#endif
+		
+		/* Set up so entry will be called on next swap */
+		t [8] = (uint32_t) (entry >> shift >> shift);
+		t [9] = (uint32_t) entry;
+		
+		t [10] = (uint32_t) (sp >> shift >> shift); 
+		t [11] = (uint32_t) sp;
+	}
+	
+	return t;
+}
+
+void co_delete( cothread_t t )
+{
+	free( t );
+}
+
+static void co_init_( void )
+{
+	#if LIBCO_MPROTECT
+		/* TODO: pre- and post-pad PPC code so that this doesn't make other
+		data executable and writable */
+		long page_size = sysconf( _SC_PAGESIZE );
+		if ( page_size > 0 )
+		{
+			uintptr_t align = page_size;
+			uintptr_t begin = (uintptr_t) libco_ppc_code;
+			uintptr_t end   = begin + sizeof libco_ppc_code;
+			
+			/* Align beginning and end */
+			end   += align - 1;
+			end   -= end   % align;
+			begin -= begin % align;
+			
+			mprotect( (void*) begin, end - begin, PROT_READ | PROT_WRITE | PROT_EXEC );
+		}
+	#endif
+    
+	co_active_handle = co_create_( state_size, (uintptr_t) &co_switch );
+}
+
+cothread_t co_active()
+{
+	if ( !co_active_handle )
+		co_init_();
+	
+	return co_active_handle;
+}
+
+void co_switch( cothread_t t )
+{
+	cothread_t old = co_active_handle;
+	co_active_handle = t;
+	
+	CO_SWAP_ASM( t, old );
+}

bsnes/libco/ppc.s

@@ -1,478 +0,0 @@
-;*****
-;libco.ppc (2007-11-29)
-;author: Vas Crabb
-;license: public domain
-;
-;cross-platform PowerPC implementation of libco
-;special thanks to byuu for writing the original version
-;
-;[ABI compatibility]
-;- gcc; mac os x; ppc
-;
-;[nonvolatile registers]
-;- GPR1, GPR13 - GPR31
-;- FPR14 - FPR31
-;- V20 - V31
-;- VRSAVE, CR2 - CR4
-;
-;[volatile registers]
-;- GPR0, GPR2 - GPR12
-;- FPR0 - FPR13
-;- V0 - V19
-;- LR, CTR, XER, CR0, CR1, CR5 - CR7
-;*****
-
-
-;Declare some target-specific stuff
-
-    .section __TEXT,__text,regular,pure_instructions
-    .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
-    .machine ppc
-
-
-;Constants
-
-    .cstring
-    .align 2
-
-_sysctl_altivec:
-    .ascii "hw.optional.altivec\0"
-
-
-;Declare space for variables
-
-.lcomm _co_environ,4,2                                      ;bit 0 = initialised, bit 1 = have Altivec/VMX
-.lcomm _co_primary_buffer,1024,2                            ;buffer (will be zeroed by loader)
-
-    .data
-    .align 2
-
-_co_active_context:
-    .long   _co_primary_buffer
-
-
-    .text
-    .align 2
-
-
-;Declare exported names
-
-.globl _co_active
-.globl _co_create
-.globl _co_delete
-.globl _co_switch
-
-
-;*****
-;extern "C" cothread_t co_active();
-;return = GPR3
-;*****
-
-_co_active:
-    mflr    r0                                              ;GPR0 = return address
-    bcl     20,31,L_co_active$spb
-L_co_active$spb:
-    mflr    r2                                              ;GPR2 set for position-independance
-    addis   r3,r2,ha16(_co_active_context-L_co_active$spb)  ;get value in GPR3
-    lwz     r3,lo16(_co_active_context-L_co_active$spb)(r3)
-    mtlr    r0                                              ;LR = return address
-    blr                                                     ;return
-
-
-;*****
-;extern "C" cothread_t co_create(unsigned int heapsize, void (*coentry)());
-;GPR3   = heapsize
-;GPR4   = coentry
-;return = GPR3
-;*****
-
-_co_create:
-    mflr    r0                                              ;GPR0 = return address
-    stmw    r30,-8(r1)                                      ;save GPR30 and GPR31
-    stw     r0,8(r1)                                        ;save return address
-    stwu    r1,-(2*4+16+24)(r1)                             ;allocate 16 bytes for locals/parameters
-
-;create heap space (stack + register storage)
-    addi    r31,r3,1024-24                                  ;subtract space for linkage
-    mr      r30,r4                                          ;GPR30 = coentry
-    addi    r3,r3,1024                                      ;allocate extra memory for contextual info
-    bl      L_malloc$stub                                   ;GPR3 = malloc(heapsize + 1024)
-    add     r4,r3,r31                                       ;GPR4 points to top-of-stack
-    rlwinm  r5,r4,0,0,27                                    ;force 16-byte alignment
-
-;store thread entry point + registers, so that first call to co_switch will execute coentry
-    stw     r30,8(r5)                                       ;store entry point
-    addi    r6,0,2+19+18*2+12*4+1                           ;clear for CR, old GPR1, 19 GPRs, 18 FPRs, 12 VRs, VRSAVE
-    addi    r0,0,0
-    addi    r7,0,4                                          ;start at 4(GPR5)
-    mtctr   r6
-L_co_create$clear_loop:
-    stwx    r0,r5,r7                                        ;clear a word
-    addi    r7,r7,-4                                        ;increment pointer
-    bdnz    L_co_create$clear_loop                          ;loop
-    stwu    r5,-448(r5)                                     ;store top of stack
-
-;initialize context memory heap and return
-    stw     r5,0(r3)                                        ;*cothread_t = stack heap pointer (GPR1)
-    lwz     r1,0(r1)                                        ;deallocate stack frame
-    lwz     r8,8(r1)                                        ;fetch return address
-    lmw     r30,-8(r1)                                      ;restore GPR30 and GPR31
-    mtlr    r8                                              ;return address in LR
-    blr                                                     ;return
-
-
-;*****
-;extern "C" void co_delete(cothread_t cothread);
-;GPR3 = cothread
-;*****
-
-_co_delete:
-    b      L_free$stub                                      ;free(GPR3)
-
-
-;*****
-;extern "C" void co_switch(cothread_t cothread);
-;GPR3 = cothread
-;*****
-;
-;Frame looks like:
-;
-;Old        New         Value
-;   8(r1)    456(r1)    Saved LR
-;   4(r1)    452(r1)    Saved CR
-;   0(r1)    448(r1)    Old GPR1
-;  -4(r1)    444(r1)    Saved GPR31
-;  -8(r1)    440(r1)    Saved GPR30
-;...        ...         ...
-; -72(r1)    376(r1)    Saved GPR14
-; -76(r1)    372(r1)    Saved GPR13
-; -80(r1)    368(r1)    Saved VRSAVE
-; -84(r1)    364(r1)    +++
-; -88(r1)    360(r1)    Saved FPR31
-; -92(r1)    356(r1)    +++
-; -96(r1)    352(r1)    Saved FPR30
-;...        ...         ...
-;-212(r1)    236(r1)    +++
-;-216(r1)    232(r1)    Saved FPR15
-;-220(r1)    228(r1)    +++
-;-224(r1)    224(r1)    Saved FPR14
-;-228(r1)    220(r1)    +++             value
-;-232(r1)    216(r1)    +++             len
-;-236(r1)    212(r1)    +++
-;-240(r1)    208(r1)    Saved VR31
-;-244(r1)    204(r1)    +++
-;-248(r1)    200(r1)    +++
-;-252(r1)    196(r1)    +++
-;-256(r1)    192(r1)    Saved VR30
-;...        ...         ...
-;-388(r1)     60(r1)    +++
-;-392(r1)     56(r1)    +++
-;-396(r1)     52(r1)    +++
-;-400(r1)     48(r1)    Saved VR21
-;-404(r1)     44(r1)    +++
-;-408(r1)     40(r1)    +++             Param 5 (GPR7)
-;-412(r1)     36(r1)    +++             Param 4 (GPR6)
-;-416(r1)     32(r1)    Saved VR20      Param 3 (GPR5)
-;-420(r1)     28(r1)    -               Param 2 (GPR4)
-;-424(r1)     24(r1)    -               Param 1 (GPR3)
-;-428(r1)     20(r1)    -               Reserved
-;-432(r1)     16(r1)    -               Reserved
-;-436(r1)     12(r1)    -               Reserved
-;-440(r1)      8(r1)    -               New LR
-;-444(r1)      4(r1)    -               New CR
-;-448(r1)      0(r1)    Saved GPR1
-
-
-_co_switch:
-    stmw    r13,-76(r1)                                     ;save preserved GPRs
-    stfd    f14,-224(r1)                                    ;save preserved FPRs
-    stfd    f15,-216(r1)
-    stfd    f16,-208(r1)
-    stfd    f17,-200(r1)
-    stfd    f18,-192(r1)
-    stfd    f19,-184(r1)
-    stfd    f20,-176(r1)
-    stfd    f21,-168(r1)
-    stfd    f22,-160(r1)
-    stfd    f23,-152(r1)
-    stfd    f24,-144(r1)
-    stfd    f25,-136(r1)
-    stfd    f26,-128(r1)
-    stfd    f27,-120(r1)
-    stfd    f28,-112(r1)
-    stfd    f29,-104(r1)
-    stfd    f30,-96(r1)
-    stfd    f31,-88(r1)
-    mflr    r0                                              ;save return address
-    stw     r0,8(r1)
-    mfcr    r2                                              ;save condition codes
-    stw     r2,4(r1)
-    stwu    r1,-448(r1)                                     ;create stack frame (save 19 GPRs, 18 FRPs, 12 VRs, VRSAVE)
-
-    mr      r30,r3                                          ;save new context pointer
-    bcl     20,31,L_co_switch$spb                           ;get address of co_active_context
-L_co_switch$spb:
-    mflr    r31
-
-    addis   r29,r31,ha16(_co_environ-L_co_switch$spb)       ;get environment flags
-    lwz     r8,lo16(_co_environ-L_co_switch$spb)(r29)
-    andis.  r9,r8,0x8000                                    ;is it initialised?
-    bne+    L_co_switch$initialised
-
-    addi    r0,0,4                                          ;len = sizeof(int)
-    stw     r0,216(r1)
-    addis   r3,r31,ha16(_sysctl_altivec-L_co_switch$spb)    ;GPR3 = "hw.optional.altivec"
-    addi    r3,r3,lo16(_sysctl_altivec-L_co_switch$spb)
-    addi    r4,r1,220                                       ;GPR4 = &value
-    addi    r5,r1,216                                       ;GPR5 = &len
-    addi    r6,0,0                                          ;newp = 0
-    addi    r7,0,0                                          ;newlen = 0
-    bl      L_sysctlbyname$stub                             ;call sysctlbyname
-    lwz     r2,220(r1)                                      ;fetch result
-    addis   r8,0,0x8000                                     ;set initialised bit
-    cmpwi   cr5,r3,0                                        ;assume error means not present
-    cmpwi   cr6,r2,0                                        ;test result
-    blt-    cr5,L_co_switch$store_environ
-    beq     cr6,L_co_switch$store_environ
-    oris    r8,r8,0x4000                                    ;set the flag to say we have it!
-L_co_switch$store_environ:
-    stw     r8,lo16(_co_environ-L_co_switch$spb)(r29)       ;store environment flags
-L_co_switch$initialised:
-
-    andis.  r10,r8,0x4000                                   ;do we have Altivec/VMX?
-    beq     L_co_switch$save_no_vmx
-    mfspr   r11,256                                         ;save VRSAVE
-    andi.   r0,r11,0x0FFF                                   ;short-circuit if it's zero
-    stw     r11,368(r1)
-    beq     L_co_switch$save_no_vmx
-    andi.   r0,r11,0x0800                                   ;check bit 20
-    addi    r2,0,32                                         ;starting index
-    beq     L_co_switch$save_skip_vr20
-    stvx    v20,r1,r2                                       ;save VR20
-L_co_switch$save_skip_vr20:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0400                                   ;check bit 21
-    beq     L_co_switch$save_skip_vr21
-    stvx    v21,r1,r2                                       ;save VR21
-L_co_switch$save_skip_vr21:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0200                                   ;check bit 22
-    beq     L_co_switch$save_skip_vr22
-    stvx    v22,r1,r2                                       ;save VR22
-L_co_switch$save_skip_vr22:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0100                                   ;check bit 23
-    beq     L_co_switch$save_skip_vr23
-    stvx    v23,r1,r2                                       ;save VR23
-L_co_switch$save_skip_vr23:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0080                                   ;check bit 24
-    beq     L_co_switch$save_skip_vr24
-    stvx    v24,r1,r2                                       ;save VR24
-L_co_switch$save_skip_vr24:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0040                                   ;check bit 25
-    beq     L_co_switch$save_skip_vr25
-    stvx    v25,r1,r2                                       ;save VR25
-L_co_switch$save_skip_vr25:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0020                                   ;check bit 26
-    beq     L_co_switch$save_skip_vr26
-    stvx    v26,r1,r2                                       ;save VR26
-L_co_switch$save_skip_vr26:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0010                                   ;check bit 27
-    beq     L_co_switch$save_skip_vr27
-    stvx    v27,r1,r2                                       ;save VR27
-L_co_switch$save_skip_vr27:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0008                                   ;check bit 28
-    beq     L_co_switch$save_skip_vr28
-    stvx    v28,r1,r2                                       ;save VR28
-L_co_switch$save_skip_vr28:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0004                                   ;check bit 29
-    beq     L_co_switch$save_skip_vr29
-    stvx    v29,r1,r2                                       ;save VR29
-L_co_switch$save_skip_vr29:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0002                                   ;check bit 30
-    beq     L_co_switch$save_skip_vr30
-    stvx    v30,r1,r2                                       ;save VR30
-L_co_switch$save_skip_vr30:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0001                                   ;check bit 31
-    beq     L_co_switch$save_skip_vr31
-    stvx    v31,r1,r2                                       ;save VR31
-L_co_switch$save_skip_vr31:
-L_co_switch$save_no_vmx:
-
-    addis   r4,r31,ha16(_co_active_context-L_co_switch$spb) ;save current context
-    lwz     r5,lo16(_co_active_context-L_co_switch$spb)(r4)
-    stw     r30,lo16(_co_active_context-L_co_switch$spb)(r4);set new context
-    stw     r1,0(r5)                                        ;save current stack pointer
-    lwz     r1,0(r30)                                       ;get new stack pointer
-
-    andis.  r10,r8,0x4000                                   ;do we have Altivec/VMX?
-    beq     L_co_switch$restore_no_vmx
-    lwz     r11,368(r1)                                     ;restore VRSAVE
-    andi.   r0,r11,0x0FFF                                   ;short-circuit if it's zero
-    mtspr   256,r11
-    beq     L_co_switch$restore_no_vmx
-    andi.   r0,r11,0x0800                                   ;check bit 20
-    addi    r2,0,32                                         ;starting index
-    beq     L_co_switch$restore_skip_vr20
-    lvx     v20,r1,r2                                       ;restore VR20
-L_co_switch$restore_skip_vr20:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0400                                   ;check bit 21
-    beq     L_co_switch$restore_skip_vr21
-    lvx     v21,r1,r2                                       ;restore VR21
-L_co_switch$restore_skip_vr21:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0200                                   ;check bit 22
-    beq     L_co_switch$restore_skip_vr22
-    lvx     v22,r1,r2                                       ;restore VR22
-L_co_switch$restore_skip_vr22:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0100                                   ;check bit 23
-    beq     L_co_switch$restore_skip_vr23
-    lvx     v23,r1,r2                                       ;restore VR23
-L_co_switch$restore_skip_vr23:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0080                                   ;check bit 24
-    beq     L_co_switch$restore_skip_vr24
-    lvx     v24,r1,r2                                       ;restore VR24
-L_co_switch$restore_skip_vr24:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0040                                   ;check bit 25
-    beq     L_co_switch$restore_skip_vr25
-    lvx     v25,r1,r2                                       ;restore VR25
-L_co_switch$restore_skip_vr25:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0020                                   ;check bit 26
-    beq     L_co_switch$restore_skip_vr26
-    lvx     v26,r1,r2                                       ;restore VR26
-L_co_switch$restore_skip_vr26:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0010                                   ;check bit 27
-    beq     L_co_switch$restore_skip_vr27
-    lvx     v27,r1,r2                                       ;restore VR27
-L_co_switch$restore_skip_vr27:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0008                                   ;check bit 28
-    beq     L_co_switch$restore_skip_vr28
-    lvx     v28,r1,r2                                       ;restore VR28
-L_co_switch$restore_skip_vr28:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0004                                   ;check bit 29
-    beq     L_co_switch$restore_skip_vr29
-    lvx     v29,r1,r2                                       ;restore VR29
-L_co_switch$restore_skip_vr29:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0002                                   ;check bit 30
-    beq     L_co_switch$restore_skip_vr30
-    lvx     v30,r1,r2                                       ;restore VR30
-L_co_switch$restore_skip_vr30:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0001                                   ;check bit 31
-    beq     L_co_switch$restore_skip_vr31
-    lvx     v31,r1,r2                                       ;restore VR31
-L_co_switch$restore_skip_vr31:
-L_co_switch$restore_no_vmx:
-
-    lwz     r1,0(r1)                                        ;deallocate stack frame
-    lwz     r6,8(r1)                                        ;return address in GPR6
-    lwz     r7,4(r1)                                        ;condition codes in GPR7
-    addi    r0,0,0                                          ;make thread main crash if it returns
-    lmw     r13,-76(r1)                                     ;restore preserved GPRs
-    lfd     f14,-224(r1)                                    ;restore preserved FPRs
-    lfd     f15,-216(r1)
-    lfd     f16,-208(r1)
-    lfd     f17,-200(r1)
-    lfd     f18,-192(r1)
-    lfd     f19,-184(r1)
-    lfd     f20,-176(r1)
-    lfd     f21,-168(r1)
-    lfd     f22,-160(r1)
-    lfd     f23,-152(r1)
-    lfd     f24,-144(r1)
-    lfd     f25,-136(r1)
-    lfd     f26,-128(r1)
-    lfd     f27,-120(r1)
-    lfd     f28,-112(r1)
-    lfd     f29,-104(r1)
-    lfd     f30,-96(r1)
-    lfd     f31,-88(r1)
-    mtlr    r0
-    mtctr   r6                                              ;restore return address
-    mtcrf   32,r7                                           ;restore preserved condition codes
-    mtcrf   16,r7
-    mtcrf   8,r7
-    bctr                                                    ;return
-
-
-
-;Import external functions
-
-    .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
-    .align 5
-L_malloc$stub:
-    .indirect_symbol _malloc
-    mflr    r0
-    bcl     20,31,L_malloc$spb
-L_malloc$spb:
-    mflr    r11
-    addis   r11,r11,ha16(L_malloc$lazy_ptr-L_malloc$spb)
-    mtlr    r0
-    lwzu    r12,lo16(L_malloc$lazy_ptr-L_malloc$spb)(r11)
-    mtctr   r12
-    bctr
-    .lazy_symbol_pointer
-L_malloc$lazy_ptr:
-    .indirect_symbol _malloc
-    .long   dyld_stub_binding_helper
-
-
-    .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
-    .align 5
-L_free$stub:
-    .indirect_symbol _free
-    mflr    r0
-    bcl     20,31,L_free$spb
-L_free$spb:
-    mflr    r11
-    addis   r11,r11,ha16(L_free$lazy_ptr-L_free$spb)
-    mtlr    r0
-    lwzu    r12,lo16(L_free$lazy_ptr-L_free$spb)(r11)
-    mtctr   r12
-    bctr
-    .lazy_symbol_pointer
-L_free$lazy_ptr:
-    .indirect_symbol _free
-    .long   dyld_stub_binding_helper
-
-
-    .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
-    .align 5
-L_sysctlbyname$stub:
-    .indirect_symbol _sysctlbyname
-    mflr    r0
-    bcl     20,31,L_sysctlbyname$spb
-L_sysctlbyname$spb:
-    mflr    r11
-    addis   r11,r11,ha16(L_sysctlbyname$lazy_ptr-L_sysctlbyname$spb)
-    mtlr    r0
-    lwzu    r12,lo16(L_sysctlbyname$lazy_ptr-L_sysctlbyname$spb)(r11)
-    mtctr   r12
-    bctr
-    .lazy_symbol_pointer
-L_sysctlbyname$lazy_ptr:
-    .indirect_symbol _sysctlbyname
-    .long   dyld_stub_binding_helper
-
-
-;This needs to be here!
-
-    .subsections_via_symbols
-

bsnes/libco/ppc64.s

@@ -1,513 +0,0 @@
-;*****
-;libco.ppc64 (2007-12-05)
-;author: Vas Crabb
-;license: public domain
-;
-;cross-platform 64-bit PowerPC implementation of libco
-;special thanks to byuu for writing the original version
-;
-;[ABI compatibility]
-;- gcc; mac os x; ppc64
-;
-;[nonvolatile registers]
-;- GPR1, GPR13 - GPR31
-;- FPR14 - FPR31
-;- V20 - V31
-;- VRSAVE, CR2 - CR4
-;
-;[volatile registers]
-;- GPR0, GPR2 - GPR12
-;- FPR0 - FPR13
-;- V0 - V19
-;- LR, CTR, XER, CR0, CR1, CR5 - CR7
-;*****
-
-
-;Declare some target-specific stuff
-
-    .section __TEXT,__text,regular,pure_instructions
-    .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
-    .machine ppc64
-
-
-;Constants
-
-    .cstring
-    .align 3
-
-_sysctl_altivec:
-    .ascii "hw.optional.altivec\0"
-
-
-;Declare space for variables
-
-.lcomm _co_environ,4,2                                      ;bit 0 = initialised, bit 1 = have Altivec/VMX
-.lcomm _co_primary_buffer,1024,3                            ;buffer (will be zeroed by loader)
-
-    .data
-    .align 3
-
-_co_active_context:
-    .quad   _co_primary_buffer
-
-
-    .text
-    .align 2
-
-
-;Declare exported names
-
-.globl _co_active
-.globl _co_create
-.globl _co_delete
-.globl _co_switch
-
-
-;*****
-;extern "C" cothread_t co_active();
-;return = GPR3
-;*****
-
-_co_active:
-    mflr    r0                                              ;GPR0 = return address
-    bcl     20,31,L_co_active$spb
-L_co_active$spb:
-    mflr    r2                                              ;GPR2 set for position-independance
-    addis   r3,r2,ha16(_co_active_context-L_co_active$spb)  ;get value in GPR3
-    ld      r3,lo16(_co_active_context-L_co_active$spb)(r3)
-    mtlr    r0                                              ;LR = return address
-    blr                                                     ;return
-
-
-;*****
-;extern "C" cothread_t co_create(unsigned int heapsize, void (*coentry)());
-;GPR3   = heapsize
-;GPR4   = coentry
-;return = GPR3
-;*****
-
-_co_create:
-    mflr    r0                                              ;GPR0 = return address
-    std     r30,-16(r1)                                     ;save GPR30 and GPR31
-    std     r31,-8(r1)
-    std     r0,16(r1)                                       ;save return address
-    stdu    r1,-(2*8+16+48)(r1)                             ;allocate 16 bytes for locals/parameters
-
-;create heap space (stack + register storage)
-    addi    r31,r3,1024-48                                  ;subtract space for linkage
-    mr      r30,r4                                          ;GPR30 = coentry
-    addi    r3,r3,1024                                      ;allocate extra memory for contextual info
-    bl      L_malloc$stub                                   ;GPR3 = malloc(heapsize + 1024)
-    add     r4,r3,r31                                       ;GPR4 points to top-of-stack
-    rldicr  r5,r4,0,59                                      ;force 16-byte alignment
-
-;store thread entry point + registers, so that first call to co_switch will execute coentry
-    std     r30,16(r5)                                      ;store entry point
-    addi    r6,0,2+19+18+12*2+1                             ;clear for CR, old GPR1, 19 GPRs, 18 FPRs, 12 VRs, VRSAVE
-    addi    r0,0,0
-    addi    r7,0,8                                          ;start at 8(GPR5)
-    mtctr   r6
-L_co_create$clear_loop:
-    stdx    r0,r5,r7                                        ;clear a double
-    addi    r7,r7,-8                                        ;increment pointer
-    bdnz    L_co_create$clear_loop                          ;loop
-    stdu    r5,-544(r5)                                     ;store top of stack
-
-;initialize context memory heap and return
-    addis   r9,0,0x8000                                     ;GPR13 not set (system TLS)
-    std     r5,0(r3)                                        ;*cothread_t = stack heap pointer (GPR1)
-    stw     r9,8(r3)                                        ;this is a flag word
-    ld      r1,0(r1)                                        ;deallocate stack frame
-    ld      r8,16(r1)                                       ;fetch return address
-    ld      r30,-16(r1)                                     ;restore GPR30 and GPR31
-    ld      r31,-8(r1)
-    mtlr    r8                                              ;return address in LR
-    blr                                                     ;return
-
-
-;*****
-;extern "C" void co_delete(cothread_t cothread);
-;GPR3 = cothread
-;*****
-
-_co_delete:
-    b      L_free$stub                                      ;free(GPR3)
-
-
-;*****
-;extern "C" void co_switch(cothread_t cothread);
-;GPR3 = cothread
-;*****
-;
-;Frame looks like:
-;
-;Old        New         Value
-;  16(r1)    560(r1)    Saved LR
-;   8(r1)    552(r1)    Saved CR
-;   0(r1)    544(r1)    Old GPR1
-;  -8(r1)    536(r1)    Saved GPR31
-; -16(r1)    528(r1)    Saved GPR30
-;...        ...         ...
-;-144(r1)    400(r1)    Saved GPR14
-;-152(r1)    392(r1)    Saved GPR13
-;-160(r1)    384(r1)    Saved FPR31
-;-168(r1)    376(r1)    Saved FPR30
-;...        ...         ...
-;-288(r1)    256(r1)    Saved FPR15
-;-296(r1)    248(r1)    Saved FPR14
-;-304(r1)    240(r1)    Saved VRSAVE
-;-312(r1)    232(r1)    +++             value
-;-320(r1)    224(r1)    Saved VR31      len
-;-328(r1)    216(r1)    +++
-;-336(r1)    208(r1)    Saved VR30
-;...        ...         ...
-;-456(r1)     88(r1)    +++
-;-464(r1)     80(r1)    Saved VR22      Param 5 (GPR7)
-;-472(r1)     72(r1)    +++             Param 4 (GPR6)
-;-480(r1)     64(r1)    Saved VR21      Param 3 (GPR5)
-;-488(r1)     56(r1)    +++             Param 2 (GPR4)
-;-496(r1)     48(r1)    Saved VR20      Param 1 (GPR3)
-;-504(r1)     40(r1)    -               Reserved
-;-512(r1)     32(r1)    -               Reserved
-;-520(r1)     24(r1)    -               Reserved
-;-528(r1)     16(r1)    -               New LR
-;-536(r1)      8(r1)    -               New CR
-;-544(r1)      0(r1)    Saved GPR1
-
-
-_co_switch:
-    std     r13,-152(r1)                                    ;save preserved GPRs
-    std     r14,-144(r1)
-    std     r15,-136(r1)
-    std     r16,-128(r1)
-    std     r17,-120(r1)
-    std     r18,-112(r1)
-    std     r19,-104(r1)
-    std     r20,-96(r1)
-    std     r21,-88(r1)
-    std     r22,-80(r1)
-    std     r23,-72(r1)
-    std     r24,-64(r1)
-    std     r25,-56(r1)
-    std     r26,-48(r1)
-    std     r27,-40(r1)
-    std     r28,-32(r1)
-    std     r29,-24(r1)
-    std     r30,-16(r1)
-    std     r31,-8(r1)
-    mflr    r0                                              ;save return address
-    std     r0,16(r1)
-    mfcr    r2                                              ;save condition codes
-    stw     r2,8(r1)
-    stdu    r1,-544(r1)                                     ;create stack frame (save 19 GPRs, 18 FRPs, 12 VRs, VRSAVE)
-    stfd    f14,248(r1)                                     ;save preserved FPRs
-    stfd    f15,256(r1)
-    stfd    f16,264(r1)
-    stfd    f17,272(r1)
-    stfd    f18,280(r1)
-    stfd    f19,288(r1)
-    stfd    f20,296(r1)
-    stfd    f21,304(r1)
-    stfd    f22,312(r1)
-    stfd    f23,320(r1)
-    stfd    f24,328(r1)
-    stfd    f25,336(r1)
-    stfd    f26,344(r1)
-    stfd    f27,352(r1)
-    stfd    f28,360(r1)
-    stfd    f29,368(r1)
-    stfd    f30,376(r1)
-    stfd    f31,384(r1)
-
-    mr      r30,r3                                          ;save new context pointer
-    bcl     20,31,L_co_switch$spb                           ;get address of co_active_context
-L_co_switch$spb:
-    mflr    r31
-
-    addis   r29,r31,ha16(_co_environ-L_co_switch$spb)       ;get environment flags
-    lwz     r8,lo16(_co_environ-L_co_switch$spb)(r29)
-    andis.  r9,r8,0x8000                                    ;is it initialised?
-    bne+    L_co_switch$initialised
-
-    addi    r0,0,4                                          ;len = sizeof(int)
-    std     r0,224(r1)
-    addis   r3,r31,ha16(_sysctl_altivec-L_co_switch$spb)    ;GPR3 = "hw.optional.altivec"
-    addi    r3,r3,lo16(_sysctl_altivec-L_co_switch$spb)
-    addi    r4,r1,232                                       ;GPR4 = &value
-    addi    r5,r1,224                                       ;GPR5 = &len
-    addi    r6,0,0                                          ;newp = 0
-    addi    r7,0,0                                          ;newlen = 0
-    bl      L_sysctlbyname$stub                             ;call sysctlbyname
-    lwz     r2,232(r1)                                      ;fetch result
-    addis   r8,0,0x8000                                     ;set initialised bit
-    cmpdi   cr5,r3,0                                        ;assume error means not present
-    cmpwi   cr6,r2,0                                        ;test result
-    blt-    cr5,L_co_switch$store_environ
-    beq     cr6,L_co_switch$store_environ
-    oris    r8,r8,0x4000                                    ;set the flag to say we have it!
-L_co_switch$store_environ:
-    stw     r8,lo16(_co_environ-L_co_switch$spb)(r29)       ;store environment flags
-L_co_switch$initialised:
-
-    andis.  r10,r8,0x4000                                   ;do we have Altivec/VMX?
-    beq     L_co_switch$save_no_vmx
-    mfspr   r11,256                                         ;save VRSAVE
-    andi.   r0,r11,0x0FFF                                   ;short-circuit if it's zero
-    stw     r11,240(r1)
-    beq     L_co_switch$save_no_vmx
-    andi.   r0,r11,0x0800                                   ;check bit 20
-    addi    r2,0,48                                         ;starting index
-    beq     L_co_switch$save_skip_vr20
-    stvx    v20,r1,r2                                       ;save VR20
-L_co_switch$save_skip_vr20:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0400                                   ;check bit 21
-    beq     L_co_switch$save_skip_vr21
-    stvx    v21,r1,r2                                       ;save VR21
-L_co_switch$save_skip_vr21:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0200                                   ;check bit 22
-    beq     L_co_switch$save_skip_vr22
-    stvx    v22,r1,r2                                       ;save VR22
-L_co_switch$save_skip_vr22:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0100                                   ;check bit 23
-    beq     L_co_switch$save_skip_vr23
-    stvx    v23,r1,r2                                       ;save VR23
-L_co_switch$save_skip_vr23:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0080                                   ;check bit 24
-    beq     L_co_switch$save_skip_vr24
-    stvx    v24,r1,r2                                       ;save VR24
-L_co_switch$save_skip_vr24:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0040                                   ;check bit 25
-    beq     L_co_switch$save_skip_vr25
-    stvx    v25,r1,r2                                       ;save VR25
-L_co_switch$save_skip_vr25:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0020                                   ;check bit 26
-    beq     L_co_switch$save_skip_vr26
-    stvx    v26,r1,r2                                       ;save VR26
-L_co_switch$save_skip_vr26:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0010                                   ;check bit 27
-    beq     L_co_switch$save_skip_vr27
-    stvx    v27,r1,r2                                       ;save VR27
-L_co_switch$save_skip_vr27:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0008                                   ;check bit 28
-    beq     L_co_switch$save_skip_vr28
-    stvx    v28,r1,r2                                       ;save VR28
-L_co_switch$save_skip_vr28:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0004                                   ;check bit 29
-    beq     L_co_switch$save_skip_vr29
-    stvx    v29,r1,r2                                       ;save VR29
-L_co_switch$save_skip_vr29:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0002                                   ;check bit 30
-    beq     L_co_switch$save_skip_vr30
-    stvx    v30,r1,r2                                       ;save VR30
-L_co_switch$save_skip_vr30:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0001                                   ;check bit 31
-    beq     L_co_switch$save_skip_vr31
-    stvx    v31,r1,r2                                       ;save VR31
-L_co_switch$save_skip_vr31:
-L_co_switch$save_no_vmx:
-
-    addis   r4,r31,ha16(_co_active_context-L_co_switch$spb) ;save current context
-    ld      r5,lo16(_co_active_context-L_co_switch$spb)(r4)
-    std     r30,lo16(_co_active_context-L_co_switch$spb)(r4);set new context
-    std     r1,0(r5)                                        ;save current stack pointer
-    ld      r1,0(r30)                                       ;get new stack pointer
-    lwz     r12,8(r30)                                      ;have we already set GPR13 (system TLS)?
-    andis.  r0,r12,0x8000
-    beq+    L_co_switch$gpr13_set
-    std     r13,392(r1)
-    xoris   r12,r12,0x8000
-    stw     r12,8(r30)
-L_co_switch$gpr13_set:
-
-    andis.  r10,r8,0x4000                                   ;do we have Altivec/VMX?
-    beq     L_co_switch$restore_no_vmx
-    lwz     r11,240(r1)                                     ;restore VRSAVE
-    andi.   r0,r11,0x0FFF                                   ;short-circuit if it's zero
-    mtspr   256,r11
-    beq     L_co_switch$restore_no_vmx
-    andi.   r0,r11,0x0800                                   ;check bit 20
-    addi    r2,0,48                                         ;starting index
-    beq     L_co_switch$restore_skip_vr20
-    lvx     v20,r1,r2                                       ;restore VR20
-L_co_switch$restore_skip_vr20:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0400                                   ;check bit 21
-    beq     L_co_switch$restore_skip_vr21
-    lvx     v21,r1,r2                                       ;restore VR21
-L_co_switch$restore_skip_vr21:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0200                                   ;check bit 22
-    beq     L_co_switch$restore_skip_vr22
-    lvx     v22,r1,r2                                       ;restore VR22
-L_co_switch$restore_skip_vr22:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0100                                   ;check bit 23
-    beq     L_co_switch$restore_skip_vr23
-    lvx     v23,r1,r2                                       ;restore VR23
-L_co_switch$restore_skip_vr23:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0080                                   ;check bit 24
-    beq     L_co_switch$restore_skip_vr24
-    lvx     v24,r1,r2                                       ;restore VR24
-L_co_switch$restore_skip_vr24:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0040                                   ;check bit 25
-    beq     L_co_switch$restore_skip_vr25
-    lvx     v25,r1,r2                                       ;restore VR25
-L_co_switch$restore_skip_vr25:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0020                                   ;check bit 26
-    beq     L_co_switch$restore_skip_vr26
-    lvx     v26,r1,r2                                       ;restore VR26
-L_co_switch$restore_skip_vr26:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0010                                   ;check bit 27
-    beq     L_co_switch$restore_skip_vr27
-    lvx     v27,r1,r2                                       ;restore VR27
-L_co_switch$restore_skip_vr27:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0008                                   ;check bit 28
-    beq     L_co_switch$restore_skip_vr28
-    lvx     v28,r1,r2                                       ;restore VR28
-L_co_switch$restore_skip_vr28:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0004                                   ;check bit 29
-    beq     L_co_switch$restore_skip_vr29
-    lvx     v29,r1,r2                                       ;restore VR29
-L_co_switch$restore_skip_vr29:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0002                                   ;check bit 30
-    beq     L_co_switch$restore_skip_vr30
-    lvx     v30,r1,r2                                       ;restore VR30
-L_co_switch$restore_skip_vr30:
-    addi    r2,r2,16                                        ;stride
-    andi.   r0,r11,0x0001                                   ;check bit 31
-    beq     L_co_switch$restore_skip_vr31
-    lvx     v31,r1,r2                                       ;restore VR31
-L_co_switch$restore_skip_vr31:
-L_co_switch$restore_no_vmx:
-
-    lfd     f14,248(r1)                                     ;restore preserved FPRs
-    lfd     f15,256(r1)
-    lfd     f16,264(r1)
-    lfd     f17,272(r1)
-    lfd     f18,280(r1)
-    lfd     f19,288(r1)
-    lfd     f20,296(r1)
-    lfd     f21,304(r1)
-    lfd     f22,312(r1)
-    lfd     f23,320(r1)
-    lfd     f24,328(r1)
-    lfd     f25,336(r1)
-    lfd     f26,344(r1)
-    lfd     f27,352(r1)
-    lfd     f28,360(r1)
-    lfd     f29,368(r1)
-    lfd     f30,376(r1)
-    lfd     f31,384(r1)
-    addi    r0,0,0                                          ;make thread main crash if it returns
-    ld      r1,0(r1)                                        ;deallocate stack frame
-    ld      r6,16(r1)                                       ;return address in GPR6
-    lwz     r7,8(r1)                                        ;condition codes in GPR7
-    ld      r13,-152(r1)                                    ;restore preserved GPRs
-    ld      r14,-144(r1)
-    ld      r15,-136(r1)
-    ld      r16,-128(r1)
-    ld      r17,-120(r1)
-    ld      r18,-112(r1)
-    ld      r19,-104(r1)
-    ld      r20,-96(r1)
-    ld      r21,-88(r1)
-    ld      r22,-80(r1)
-    ld      r23,-72(r1)
-    ld      r24,-64(r1)
-    ld      r25,-56(r1)
-    ld      r26,-48(r1)
-    ld      r27,-40(r1)
-    ld      r28,-32(r1)
-    ld      r29,-24(r1)
-    ld      r30,-16(r1)
-    ld      r31,-8(r1)
-    mtlr    r0
-    mtctr   r6                                              ;restore return address
-    mtcrf   32,r7                                           ;restore preserved condition codes
-    mtcrf   16,r7
-    mtcrf   8,r7
-    bctr                                                    ;return
-
-
-
-;Import external functions
-
-    .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
-    .align 5
-L_malloc$stub:
-    .indirect_symbol _malloc
-    mflr    r0
-    bcl     20,31,L_malloc$spb
-L_malloc$spb:
-    mflr    r11
-    addis   r11,r11,ha16(L_malloc$lazy_ptr-L_malloc$spb)
-    mtlr    r0
-    ldu     r12,lo16(L_malloc$lazy_ptr-L_malloc$spb)(r11)
-    mtctr   r12
-    bctr
-    .lazy_symbol_pointer
-L_malloc$lazy_ptr:
-    .indirect_symbol _malloc
-    .quad   dyld_stub_binding_helper
-
-
-    .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
-    .align 5
-L_free$stub:
-    .indirect_symbol _free
-    mflr    r0
-    bcl     20,31,L_free$spb
-L_free$spb:
-    mflr    r11
-    addis   r11,r11,ha16(L_free$lazy_ptr-L_free$spb)
-    mtlr    r0
-    ldu     r12,lo16(L_free$lazy_ptr-L_free$spb)(r11)
-    mtctr   r12
-    bctr
-    .lazy_symbol_pointer
-L_free$lazy_ptr:
-    .indirect_symbol _free
-    .quad   dyld_stub_binding_helper
-
-
-    .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
-    .align 5
-L_sysctlbyname$stub:
-    .indirect_symbol _sysctlbyname
-    mflr    r0
-    bcl     20,31,L_sysctlbyname$spb
-L_sysctlbyname$spb:
-    mflr    r11
-    addis   r11,r11,ha16(L_sysctlbyname$lazy_ptr-L_sysctlbyname$spb)
-    mtlr    r0
-    ldu     r12,lo16(L_sysctlbyname$lazy_ptr-L_sysctlbyname$spb)(r11)
-    mtctr   r12
-    bctr
-    .lazy_symbol_pointer
-L_sysctlbyname$lazy_ptr:
-    .indirect_symbol _sysctlbyname
-    .quad   dyld_stub_binding_helper
-
-
-;This needs to be here!
-
-    .subsections_via_symbols
-

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

@@ -45,11 +45,11 @@ namespace nall {
 
       void set(string s) {
         switch(type) {
-          case boolean_t:  *(bool*)data = (s == "true");      break;
-          case signed_t:   *(signed*)data = strsigned(s);     break;
-          case unsigned_t: *(unsigned*)data = strunsigned(s); break;
-          case double_t:   *(double*)data = strdouble(s);     break;
-          case string_t:   s.trim("\""); *(string*)data = s;  break;
+          case boolean_t:  *(bool*)data = (s == "true");     break;
+          case signed_t:   *(signed*)data = integer(s);      break;
+          case unsigned_t: *(unsigned*)data = decimal(s);    break;
+          case double_t:   *(double*)data = fp(s);           break;
+          case string_t:   s.trim("\""); *(string*)data = s; break;
         }
       }
     };
@@ -102,7 +102,7 @@ namespace nall {
 
     virtual bool save(const char *filename) const {
       file fp;
-      if(fp.open(filename, file::mode_write)) {
+      if(fp.open(filename, file::mode::write)) {
         for(unsigned i = 0; i < list.size(); i++) {
           string output;
           output << list[i].name << " = " << list[i].get();

bsnes/nall/dictionary.hpp

@@ -27,7 +27,7 @@ namespace nall {
     bool import(const char *filename) {
       string data;
       if(data.readfile(filename) == false) return false;
-      data.ltrim_once("\xef\xbb\xbf"); //remove UTF-8 marker, if it exists
+      data.ltrim<1>("\xef\xbb\xbf"); //remove UTF-8 marker, if it exists
       data.replace("\r", "");
 
       lstring line;
@@ -43,8 +43,8 @@ namespace nall {
         part[1].trim();
 
         //remove quotes
-        part[0].trim_once("\"");
-        part[1].trim_once("\"");
+        part[0].trim<1>("\"");
+        part[1].trim<1>("\"");
 
         unsigned n = index_input.size();
         index_input[n]  = part[0];

bsnes/nall/directory.hpp

@@ -16,13 +16,20 @@
 namespace nall {
 
 struct directory {
-  static lstring folders(const char *pathname);
-  static lstring files(const char *pathname);
-  static lstring contents(const char *pathname);
+  static bool exists(const string &pathname);
+  static lstring folders(const string &pathname, const string &pattern = "*");
+  static lstring files(const string &pathname, const string &pattern = "*");
+  static lstring contents(const string &pathname, const string &pattern = "*");
 };
 
 #if defined(_WIN32)
-  inline lstring directory::folders(const char *pathname) {
+  inline bool directory::exists(const string &pathname) {
+    DWORD result = GetFileAttributes(utf16_t(pathname));
+    if(result == INVALID_FILE_ATTRIBUTES) return false;
+    return (result & FILE_ATTRIBUTE_DIRECTORY);
+  }
+
+  inline lstring directory::folders(const string &pathname, const string &pattern) {
     lstring list;
     string path = pathname;
     path.transform("/", "\\");
@@ -34,23 +41,26 @@ struct directory {
     if(handle != INVALID_HANDLE_VALUE) {
       if(wcscmp(data.cFileName, L".") && wcscmp(data.cFileName, L"..")) {
         if(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-          list.append(string(utf8_t(data.cFileName), "/"));
+          string name = (const char*)utf8_t(data.cFileName);
+          if(wildcard(name, pattern)) list.append(name);
         }
       }
       while(FindNextFile(handle, &data) != false) {
         if(wcscmp(data.cFileName, L".") && wcscmp(data.cFileName, L"..")) {
           if(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-            list.append(string(utf8_t(data.cFileName), "/"));
+            string name = (const char*)utf8_t(data.cFileName);
+            if(wildcard(name, pattern)) list.append(name);
           }
         }
       }
       FindClose(handle);
     }
-    sort(&list[0], list.size());
+    if(list.size() > 0) sort(&list[0], list.size());
+    foreach(name, list) name.append("/");  //must append after sorting
     return list;
   }
 
-  inline lstring directory::files(const char *pathname) {
+  inline lstring directory::files(const string &pathname, const string &pattern) {
     lstring list;
     string path = pathname;
     path.transform("/", "\\");
@@ -61,27 +71,36 @@ struct directory {
     handle = FindFirstFile(utf16_t(path), &data);
     if(handle != INVALID_HANDLE_VALUE) {
       if((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
-        list.append(utf8_t(data.cFileName));
+        string name = (const char*)utf8_t(data.cFileName);
+        if(wildcard(name, pattern)) list.append(name);
       }
       while(FindNextFile(handle, &data) != false) {
         if((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
-          list.append(utf8_t(data.cFileName));
+          string name = (const char*)utf8_t(data.cFileName);
+          if(wildcard(name, pattern)) list.append(name);
         }
       }
       FindClose(handle);
     }
-    sort(&list[0], list.size());
+    if(list.size() > 0) sort(&list[0], list.size());
     return list;
   }
 
-  inline lstring directory::contents(const char *pathname) {
-    lstring folders = directory::folders(pathname);
-    lstring files = directory::files(pathname);
+  inline lstring directory::contents(const string &pathname, const string &pattern) {
+    lstring folders = directory::folders(pathname);  //pattern search of contents() should only filter files
+    lstring files = directory::files(pathname, pattern);
     foreach(file, files) folders.append(file);
     return folders;
   }
 #else
-  inline lstring directory::folders(const char *pathname) {
+  inline bool directory::exists(const string &pathname) {
+    DIR *dp = opendir(pathname);
+    if(!dp) return false;
+    closedir(dp);
+    return true;
+  }
+
+  inline lstring directory::folders(const string &pathname, const string &pattern) {
     lstring list;
     DIR *dp;
     struct dirent *ep;
@@ -90,16 +109,18 @@ struct directory {
       while(ep = readdir(dp)) {
         if(!strcmp(ep->d_name, ".")) continue;
         if(!strcmp(ep->d_name, "..")) continue;
-        if(ep->d_type & DT_DIR) list.append(string(ep->d_name, "/"));
+        if(ep->d_type & DT_DIR) {
+          if(wildcard(ep->d_name, pattern)) list.append(ep->d_name);
+        }
       }
       closedir(dp);
     }
-    sort(&list[0], list.size());
+    if(list.size() > 0) sort(&list[0], list.size());
+    foreach(name, list) name.append("/");  //must append after sorting
     return list;
-
   }
 
-  inline lstring directory::files(const char *pathname) {
+  inline lstring directory::files(const string &pathname, const string &pattern) {
     lstring list;
     DIR *dp;
     struct dirent *ep;
@@ -108,17 +129,19 @@ struct directory {
       while(ep = readdir(dp)) {
         if(!strcmp(ep->d_name, ".")) continue;
         if(!strcmp(ep->d_name, "..")) continue;
-        if((ep->d_type & DT_DIR) == 0) list.append(ep->d_name);
+        if((ep->d_type & DT_DIR) == 0) {
+          if(wildcard(ep->d_name, pattern)) list.append(ep->d_name);
+        }
       }
       closedir(dp);
     }
-    sort(&list[0], list.size());
+    if(list.size() > 0) sort(&list[0], list.size());
     return list;
   }
 
-  inline lstring directory::contents(const char *pathname) {
-    lstring folders = directory::folders(pathname);
-    lstring files = directory::files(pathname);
+  inline lstring directory::contents(const string &pathname, const string &pattern) {
+    lstring folders = directory::folders(pathname);  //pattern search of contents() should only filter files
+    lstring files = directory::files(pathname, pattern);
     foreach(file, files) folders.append(file);
     return folders;
   }

bsnes/nall/dl.hpp

@@ -19,6 +19,7 @@ namespace nall {
   struct library {
     bool opened() const { return handle; }
     bool open(const char*, const char* = "");
+    bool open_absolute(const char*);
     void* sym(const char*);
     void close();
 
@@ -40,6 +41,12 @@ namespace nall {
     return handle;
   }
 
+  inline bool library::open_absolute(const char *name) {
+    if(handle) close();
+    handle = (uintptr_t)dlopen(name, RTLD_LAZY);
+    return handle;
+  }
+
   inline void* library::sym(const char *name) {
     if(!handle) return 0;
     return dlsym((void*)handle, name);
@@ -58,6 +65,12 @@ namespace nall {
     return handle;
   }
 
+  inline bool library::open_absolute(const char *name) {
+    if(handle) close();
+    handle = (uintptr_t)dlopen(name, RTLD_LAZY);
+    return handle;
+  }
+
   inline void* library::sym(const char *name) {
     if(!handle) return 0;
     return dlsym((void*)handle, name);
@@ -76,6 +89,12 @@ namespace nall {
     return handle;
   }
 
+  inline bool library::open_absolute(const char *name) {
+    if(handle) close();
+    handle = (uintptr_t)LoadLibraryW(utf16_t(name));
+    return handle;
+  }
+
   inline void* library::sym(const char *name) {
     if(!handle) return 0;
     return (void*)GetProcAddress((HMODULE)handle, name);

bsnes/nall/file.hpp

@@ -1,15 +1,7 @@
 #ifndef NALL_FILE_HPP
 #define NALL_FILE_HPP
 
-#include <stdio.h>
-#include <string.h>
-
-#if !defined(_WIN32)
-  #include <unistd.h>
-#else
-  #include <io.h>
-#endif
-
+#include <nall/platform.hpp>
 #include <nall/stdint.hpp>
 #include <nall/string.hpp>
 #include <nall/utf8.hpp>
@@ -26,12 +18,13 @@ namespace nall {
 
   class file {
   public:
-    enum FileMode { mode_read, mode_write, mode_readwrite, mode_writeread };
-    enum SeekMode { seek_absolute, seek_relative };
+    enum class mode : unsigned { read, write, readwrite, writeread };
+    enum class index : unsigned { absolute, relative };
+    enum class time : unsigned { create, modify, access };
 
     uint8_t read() {
       if(!fp) return 0xff;                       //file not open
-      if(file_mode == mode_write) return 0xff;   //reads not permitted
+      if(file_mode == mode::write) return 0xff;  //reads not permitted
       if(file_offset >= file_size) return 0xff;  //cannot read past end of file
       buffer_sync();
       return buffer[(file_offset++) & buffer_mask];
@@ -59,8 +52,8 @@ namespace nall {
     }
 
     void write(uint8_t data) {
-      if(!fp) return;                     //file not open
-      if(file_mode == mode_read) return;  //writes not permitted
+      if(!fp) return;                      //file not open
+      if(file_mode == mode::read) return;  //writes not permitted
       buffer_sync();
       buffer[(file_offset++) & buffer_mask] = data;
       buffer_dirty = true;
@@ -95,19 +88,19 @@ namespace nall {
       fflush(fp);
     }
 
-    void seek(int offset, SeekMode mode = seek_absolute) {
+    void seek(int offset, index index_ = index::absolute) {
       if(!fp) return;  //file not open
       buffer_flush();
 
       uintmax_t req_offset = file_offset;
-      switch(mode) {
-        case seek_absolute: req_offset  = offset; break;
-        case seek_relative: req_offset += offset; break;
+      switch(index_) {
+        case index::absolute: req_offset  = offset; break;
+        case index::relative: req_offset += offset; break;
       }
 
       if(req_offset < 0) req_offset = 0;  //cannot seek before start of file
       if(req_offset > file_size) {
-        if(file_mode == mode_read) {      //cannot seek past end of file
+        if(file_mode == mode::read) {     //cannot seek past end of file
           req_offset = file_size;
         } else {                          //pad file to requested location
           file_offset = file_size;
@@ -142,52 +135,60 @@ namespace nall {
       return file_offset >= file_size;
     }
 
-    static bool exists(const char *fn) {
+    static bool exists(const char *filename) {
       #if !defined(_WIN32)
-      FILE *fp = fopen(fn, "rb");
+      struct stat64 data;
+      return stat64(filename, &data) == 0;
       #else
-      FILE *fp = _wfopen(utf16_t(fn), L"rb");
+      struct __stat64 data;
+      return _wstat64(utf16_t(filename), &data) == 0;
       #endif
-      if(fp) {
-        fclose(fp);
-        return true;
-      }
-      return false;
     }
 
-    static unsigned size(const char *fn) {
+    static uintmax_t size(const char *filename) {
       #if !defined(_WIN32)
-      FILE *fp = fopen(fn, "rb");
+      struct stat64 data;
+      stat64(filename, &data);
       #else
-      FILE *fp = _wfopen(utf16_t(fn), L"rb");
+      struct __stat64 data;
+      _wstat64(utf16_t(filename), &data);
       #endif
-      unsigned filesize = 0;
-      if(fp) {
-        fseek(fp, 0, SEEK_END);
-        filesize = ftell(fp);
-        fclose(fp);
+      return S_ISREG(data.st_mode) ? data.st_size : 0u;
+    }
+
+    static time_t timestamp(const char *filename, file::time mode = file::time::create) {
+      #if !defined(_WIN32)
+      struct stat64 data;
+      stat64(filename, &data);
+      #else
+      struct __stat64 data;
+      _wstat64(utf16_t(filename), &data);
+      #endif
+      switch(mode) { default:
+        case file::time::create: return data.st_ctime;
+        case file::time::modify: return data.st_mtime;
+        case file::time::access: return data.st_atime;
       }
-      return filesize;
     }
 
     bool open() {
       return fp;
     }
 
-    bool open(const char *fn, FileMode mode) {
+    bool open(const char *filename, mode mode_) {
       if(fp) return false;
 
-      switch(file_mode = mode) {
+      switch(file_mode = mode_) {
         #if !defined(_WIN32)
-        case mode_read:      fp = fopen(fn, "rb");  break;
-        case mode_write:     fp = fopen(fn, "wb+"); break;  //need read permission for buffering
-        case mode_readwrite: fp = fopen(fn, "rb+"); break;
-        case mode_writeread: fp = fopen(fn, "wb+"); break;
+        case mode::read:      fp = fopen(filename, "rb" ); break;
+        case mode::write:     fp = fopen(filename, "wb+"); break;  //need read permission for buffering
+        case mode::readwrite: fp = fopen(filename, "rb+"); break;
+        case mode::writeread: fp = fopen(filename, "wb+"); break;
         #else
-        case mode_read:      fp = _wfopen(utf16_t(fn), L"rb");  break;
-        case mode_write:     fp = _wfopen(utf16_t(fn), L"wb+"); break;
-        case mode_readwrite: fp = _wfopen(utf16_t(fn), L"rb+"); break;
-        case mode_writeread: fp = _wfopen(utf16_t(fn), L"wb+"); break;
+        case mode::read:      fp = _wfopen(utf16_t(filename), L"rb" ); break;
+        case mode::write:     fp = _wfopen(utf16_t(filename), L"wb+"); break;
+        case mode::readwrite: fp = _wfopen(utf16_t(filename), L"rb+"); break;
+        case mode::writeread: fp = _wfopen(utf16_t(filename), L"wb+"); break;
         #endif
       }
       if(!fp) return false;
@@ -213,7 +214,7 @@ namespace nall {
       fp = 0;
       file_offset = 0;
       file_size = 0;
-      file_mode = mode_read;
+      file_mode = mode::read;
     }
 
     ~file() {
@@ -231,7 +232,7 @@ namespace nall {
     FILE *fp;
     unsigned file_offset;
     unsigned file_size;
-    FileMode file_mode;
+    mode file_mode;
 
     void buffer_sync() {
       if(!fp) return;  //file not open
@@ -245,14 +246,14 @@ namespace nall {
     }
 
     void buffer_flush() {
-      if(!fp) return;                     //file not open
-      if(file_mode == mode_read) return;  //buffer cannot be written to
-      if(buffer_offset < 0) return;       //buffer unused
-      if(buffer_dirty == false) return;   //buffer unmodified since read
+      if(!fp) return;                      //file not open
+      if(file_mode == mode::read) return;  //buffer cannot be written to
+      if(buffer_offset < 0) return;        //buffer unused
+      if(buffer_dirty == false) return;    //buffer unmodified since read
       fseek(fp, buffer_offset, SEEK_SET);
       unsigned length = (buffer_offset + buffer_size) <= file_size ? buffer_size : (file_size & buffer_mask);
       if(length) unsigned unused = fwrite(buffer, 1, length, fp);
-      buffer_offset = -1;                 //invalidate buffer
+      buffer_offset = -1;                  //invalidate buffer
       buffer_dirty = false;
     }
   };

bsnes/nall/filemap.hpp

@@ -19,14 +19,16 @@
 namespace nall {
   class filemap {
   public:
-    enum filemode { mode_read, mode_write, mode_readwrite, mode_writeread };
+    enum class mode : unsigned { read, write, readwrite, writeread };
 
-    bool open(const char *filename, filemode mode) { return p_open(filename, mode); }
+    bool open() const { return p_open(); }
+    bool open(const char *filename, mode mode_) { return p_open(filename, mode_); }
     void close() { return p_close(); }
     unsigned size() const { return p_size; }
-    uint8_t* handle() { return p_handle; }
-    const uint8_t* handle() const { return p_handle; }
+    uint8_t* data() { return p_handle; }
+    const uint8_t* data() const { return p_handle; }
     filemap() : p_size(0), p_handle(0) { p_ctor(); }
+    filemap(const char *filename, mode mode_) : p_size(0), p_handle(0) { p_ctor(); p_open(filename, mode_); }
     ~filemap() { p_dtor(); }
 
   private:
@@ -40,31 +42,35 @@ namespace nall {
 
     HANDLE p_filehandle, p_maphandle;
 
-    bool p_open(const char *filename, filemode mode) {
+    bool p_open() const {
+      return p_handle;
+    }
+
+    bool p_open(const char *filename, mode mode_) {
       int desired_access, creation_disposition, flprotect, map_access;
 
-      switch(mode) {
+      switch(mode_) {
         default: return false;
-        case mode_read:
+        case mode::read:
           desired_access = GENERIC_READ;
           creation_disposition = OPEN_EXISTING;
           flprotect = PAGE_READONLY;
           map_access = FILE_MAP_READ;
           break;
-        case mode_write:
+        case mode::write:
           //write access requires read access
           desired_access = GENERIC_WRITE;
           creation_disposition = CREATE_ALWAYS;
           flprotect = PAGE_READWRITE;
           map_access = FILE_MAP_ALL_ACCESS;
           break;
-        case mode_readwrite:
+        case mode::readwrite:
           desired_access = GENERIC_READ | GENERIC_WRITE;
           creation_disposition = OPEN_EXISTING;
           flprotect = PAGE_READWRITE;
           map_access = FILE_MAP_ALL_ACCESS;
           break;
-        case mode_writeread:
+        case mode::writeread:
           desired_access = GENERIC_READ | GENERIC_WRITE;
           creation_disposition = CREATE_NEW;
           flprotect = PAGE_READWRITE;
@@ -122,30 +128,34 @@ namespace nall {
 
     int p_fd;
 
-    bool p_open(const char *filename, filemode mode) {
+    bool p_open() const {
+      return p_handle;
+    }
+
+    bool p_open(const char *filename, mode mode_) {
       int open_flags, mmap_flags;
 
-      switch(mode) {
+      switch(mode_) {
         default: return false;
-        case mode_read:
+        case mode::read:
           open_flags = O_RDONLY;
           mmap_flags = PROT_READ;
           break;
-        case mode_write:
+        case mode::write:
           open_flags = O_RDWR | O_CREAT;  //mmap() requires read access
           mmap_flags = PROT_WRITE;
           break;
-        case mode_readwrite:
+        case mode::readwrite:
           open_flags = O_RDWR;
           mmap_flags = PROT_READ | PROT_WRITE;
           break;
-        case mode_writeread:
+        case mode::writeread:
           open_flags = O_RDWR | O_CREAT;
           mmap_flags = PROT_READ | PROT_WRITE;
           break;
       }
 
-      p_fd = ::open(filename, open_flags);
+      p_fd = ::open(filename, open_flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
       if(p_fd < 0) return false;
 
       struct stat p_stat;

bsnes/nall/foreach.hpp

@@ -5,8 +5,14 @@
 #include <nall/concept.hpp>
 
 #undef foreach
-#define foreach(iter, object) \
+
+#define foreach2(iter, object) foreach3(iter, object, foreach_counter)
+#define foreach3(iter, object, foreach_counter) \
   for(unsigned foreach_counter = 0, foreach_limit = container_size(object), foreach_once = 0, foreach_broken = 0; foreach_counter < foreach_limit && foreach_broken == 0; foreach_counter++, foreach_once = 0) \
     for(auto &iter = object[foreach_counter]; foreach_once == 0 && (foreach_broken = 1); foreach_once++, foreach_broken = 0)
 
+#define foreach_impl(...) foreach_decl(__VA_ARGS__, foreach3(__VA_ARGS__), foreach2(__VA_ARGS__), foreach_too_few_arguments)
+#define foreach_decl(_1, _2, _3, N, ...) N
+#define foreach(...) foreach_impl(__VA_ARGS__)
+
 #endif

bsnes/nall/function.hpp

@@ -1,90 +1,59 @@
 #ifndef NALL_FUNCTION_HPP
 #define NALL_FUNCTION_HPP
 
-#include <stdlib.h>
-#include <functional>
-#include <type_traits>
-
 namespace nall {
   template<typename T> class function;
 
-  template<typename R, typename... P>
-  class function<R (P...)> {
-  private:
-    struct base1 { virtual void func1(P...) {} };
-    struct base2 { virtual void func2(P...) {} };
-    struct derived : base1, virtual base2 {};
+  template<typename R, typename... P> class function<R (P...)> {
+    struct container {
+      virtual R operator()(P... p) const = 0;
+      virtual container* copy() const = 0;
+      virtual ~container() {}
+    } *callback;
 
-    struct data_t {
-      R (*callback)(const data_t&, P...);
-      union {
-        R (*callback_global)(P...);
-        struct {
-          R (derived::*callback_member)(P...);
-          void *object;
-        };
-      };
-    } data;
+    struct global : container {
+      R (*function)(P...);
+      R operator()(P... p) const { return function(std::forward<P>(p)...); }
+      container* copy() const { return new global(function); }
+      global(R (*function)(P...)) : function(function) {}
+    };
 
-    static R callback_global(const data_t &data, P... p) {
-      return data.callback_global(p...);
-    }
+    template<typename C> struct member : container {
+      R (C::*function)(P...);
+      C *object;
+      R operator()(P... p) const { return (object->*function)(std::forward<P>(p)...); }
+      container* copy() const { return new member(function, object); }
+      member(R (C::*function)(P...), C *object) : function(function), object(object) {}
+    };
 
-    template<typename C>
-    static R callback_member(const data_t &data, P... p) {
-      return (((C*)data.object)->*((R (C::*&)(P...))data.callback_member))(p...);
-    }
+    template<typename L> struct lambda : container {
+      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) {}
+    };
 
   public:
-    R operator()(P... p) const { return data.callback(data, p...); }
-    operator bool() const { return data.callback; }
-    void reset() { data.callback = 0; }
+    operator bool() const { return callback; }
+    R operator()(P... p) const { return (*callback)(std::forward<P>(p)...); }
+    void reset() { if(callback) { delete callback; callback = 0; } }
 
-    function& operator=(const function &source) { memcpy(&data, &source.data, sizeof(data_t)); return *this; }
-    function(const function &source) { operator=(source); }
-
-    //no pointer
-    function() {
-      data.callback = 0;
+    function& operator=(const function &source) {
+      if(this != &source) {
+        if(callback) { delete callback; callback = 0; }
+        if(source.callback) callback = source.callback->copy();
+      }
+      return *this;
     }
 
-    //symbolic link pointer (nall/dl.hpp::sym, etc)
-    function(void *callback) {
-      data.callback = callback ? &callback_global : 0;
-      data.callback_global = (R (*)(P...))callback;
-    }
-
-    //global function pointer
-    function(R (*callback)(P...)) {
-      data.callback = &callback_global;
-      data.callback_global = callback;
-    }
-
-    //member function pointer
-    template<typename C>
-    function(R (C::*callback)(P...), C *object) {
-      static_assert(sizeof data.callback_member >= sizeof callback, "callback_member is too small");
-      data.callback = &callback_member<C>;
-      (R (C::*&)(P...))data.callback_member = callback;
-      data.object = object;
-    }
-
-    //const member function pointer
-    template<typename C>
-    function(R (C::*callback)(P...) const, C *object) {
-      static_assert(sizeof data.callback_member >= sizeof callback, "callback_member is too small");
-      data.callback = &callback_member<C>;
-      (R (C::*&)(P...))data.callback_member = (R (C::*&)(P...))callback;
-      data.object = object;
-    }
-
-    //lambda function pointer
-    template<typename T>
-    function(T callback) {
-      static_assert(std::is_same<R, typename std::result_of<T(P...)>::type>::value, "lambda mismatch");
-      data.callback = &callback_global;
-      data.callback_global = (R (*)(P...))callback;
-    }
+    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); }
+    template<typename C> function(R (C::*function)(P...), C *object) { callback = new member<C>(function, object); }
+    template<typename C> function(R (C::*function)(P...) const, C *object) { callback = new member<C>((R (C::*)(P...))function, object); }
+    template<typename L> function(const L& object) { callback = new lambda<L>(object); }
+    ~function() { if(callback) delete callback; }
   };
 }
 

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

@@ -92,7 +92,7 @@ struct Keyboard {
     string s(name);
     if(!strbegin(name, "KB")) return 0;
     s.ltrim("KB");
-    unsigned id = strunsigned(s);
+    unsigned id = decimal(s);
     auto pos = strpos(s, "::");
     if(!pos) return 0;
     s = substr(s, pos() + 2);
@@ -189,7 +189,7 @@ struct Mouse {
     string s(name);
     if(!strbegin(name, "MS")) return 0;
     s.ltrim("MS");
-    unsigned id = strunsigned(s);
+    unsigned id = decimal(s);
     auto pos = strpos(s, "::");
     if(!pos) return 0;
     s = substr(s, pos() + 2);
@@ -313,7 +313,7 @@ struct Joypad {
     string s(name);
     if(!strbegin(name, "JP")) return 0;
     s.ltrim("JP");
-    unsigned id = strunsigned(s);
+    unsigned id = decimal(s);
     auto pos = strpos(s, "::");
     if(!pos) return 0;
     s = substr(s, pos() + 2);

bsnes/nall/platform.hpp

@@ -1,6 +1,12 @@
 #ifndef NALL_PLATFORM_HPP
 #define NALL_PLATFORM_HPP
 
+#if defined(_WIN32)
+  //minimum version needed for _wstat64, etc
+  #undef  __MSVCRT_VERSION__
+  #define __MSVCRT_VERSION__ 0x0601
+#endif
+
 #include <nall/utf8.hpp>
 
 //=========================
@@ -18,16 +24,19 @@
 #include <string.h>
 #include <time.h>
 
+#include <sys/types.h>
+#include <sys/stat.h>
+
 #if defined(_WIN32)
   #include <io.h>
   #include <direct.h>
   #include <shlobj.h>
+  #include <wchar.h>
   #undef interface
   #define dllexport __declspec(dllexport)
 #else
   #include <unistd.h>
   #include <pwd.h>
-  #include <sys/stat.h>
   #define dllexport
 #endif
 
@@ -53,11 +62,11 @@
 #if defined(_WIN32)
   #define getcwd      _getcwd
   #define ftruncate   _chsize
-  #define putenv      _putenv
   #define mkdir(n, m) _wmkdir(nall::utf16_t(n))
+  #define putenv      _putenv
   #define rmdir       _rmdir
-  #define vsnprintf   _vsnprintf
   #define usleep(n)   Sleep(n / 1000)
+  #define vsnprintf   _vsnprintf
 #endif
 
 //================

bsnes/nall/public_cast.hpp

@@ -0,0 +1,32 @@
+#ifndef NALL_PUBLIC_CAST_HPP
+#define NALL_PUBLIC_CAST_HPP
+
+//this is a proof-of-concept-*only* C++ access-privilege elevation exploit.
+//this code is 100% legal C++, per C++98 section 14.7.2 paragraph 8:
+//"access checking rules do not apply to names in explicit instantiations."
+//usage example:
+
+//struct N { typedef void (Class::*)(); };
+//template class public_cast<N, &Class::Reference>;
+//(class.*public_cast<N>::value);
+
+//Class::Reference may be public, protected or private
+//Class::Reference may be a function, object or variable
+
+namespace nall {
+  template<typename T, typename T::type... P> struct public_cast;
+
+  template<typename T> struct public_cast<T> {
+    static typename T::type value;
+  };
+
+  template<typename T> typename T::type public_cast<T>::value;
+
+  template<typename T, typename T::type P> struct public_cast<T, P> {
+    static typename T::type value;
+  };
+
+  template<typename T, typename T::type P> typename T::type public_cast<T, P>::value = public_cast<T>::value = P;
+}
+
+#endif

bsnes/nall/qt/Makefile

@@ -1,55 +0,0 @@
-# requires nall/Makefile
-
-# imports:
-# $(qtlibs) -- list of Qt components to link against
-
-# exports the following symbols:
-# $(moc)   -- meta-object compiler
-# $(rcc)   -- resource compiler
-# $(qtinc) -- includes for compiling
-# $(qtlib) -- libraries for linking
-
-ifeq ($(moc),)
-moc := moc
-endif
-
-ifeq ($(rcc),)
-rcc := rcc
-endif
-
-ifeq ($(platform),x)
-  qtinc := `pkg-config --cflags $(qtlibs)`
-  qtlib := `pkg-config --libs $(qtlibs)`
-else ifeq ($(platform),osx)
-  qtinc := $(foreach lib,$(qtlibs),-I/Library/Frameworks/$(lib).framework/Versions/4/Headers)
-
-  qtlib := -L/Library/Frameworks
-  qtlib += $(foreach lib,$(qtlibs),-framework $(lib))
-  qtlib += -framework Carbon
-  qtlib += -framework Cocoa
-  qtlib += -framework OpenGL
-  qtlib += -framework AppKit
-  qtlib += -framework ApplicationServices
-else ifeq ($(platform),win)
-  ifeq ($(qtpath),)
-    # find Qt install directory from PATH environment variable
-    qtpath := $(foreach path,$(subst ;, ,$(PATH)),$(if $(wildcard $(path)/$(moc).exe),$(path)))
-    qtpath := $(strip $(qtpath))
-    qtpath := $(subst \,/,$(qtpath))
-    qtpath := $(patsubst %/bin,%,$(qtpath))
-  endif
-
-  qtinc := -I$(qtpath)/include
-  qtinc += $(foreach lib,$(qtlibs),-I$(qtpath)/include/$(lib))
-
-  qtlib := -L$(qtpath)/lib
-  qtlib += -L$(qtpath)/plugins/imageformats
-
-  qtlib += $(foreach lib,$(qtlibs),-l$(lib)4)
-  qtlib += -lmingw32 -lqtmain -lcomdlg32 -loleaut32 -limm32 -lwinmm
-  qtlib += -lwinspool -lmsimg32 -lole32 -ladvapi32 -lws2_32 -luuid -lgdi32
-  qtlib += $(foreach lib,$(qtlibs),-l$(lib)4)
-
-  # optional image-file support:
-  # qtlib += -lqjpeg -lqmng
-endif

bsnes/nall/qt/check-action.moc.hpp

@@ -1,41 +0,0 @@
-#ifndef NALL_QT_CHECKACTION_HPP
-#define NALL_QT_CHECKACTION_HPP
-
-namespace nall {
-
-class CheckAction : public QAction {
-  Q_OBJECT
-
-public:
-  bool isChecked() const;
-  void setChecked(bool);
-  void toggleChecked();
-  CheckAction(const QString&, QObject*);
-
-protected slots:
-
-protected:
-  bool checked;
-};
-
-inline bool CheckAction::isChecked() const {
-  return checked;
-}
-
-inline void CheckAction::setChecked(bool checked_) {
-  checked = checked_;
-  if(checked) setIcon(QIcon(":/16x16/item-check-on.png"));
-  else setIcon(QIcon(":/16x16/item-check-off.png"));
-}
-
-inline void CheckAction::toggleChecked() {
-  setChecked(!isChecked());
-}
-
-inline CheckAction::CheckAction(const QString &text, QObject *parent) : QAction(text, parent) {
-  setChecked(false);
-}
-
-}
-
-#endif

bsnes/nall/qt/concept.hpp

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

bsnes/nall/qt/file-dialog.moc.hpp

@@ -1,392 +0,0 @@
-#ifndef NALL_QT_FILEDIALOG_HPP
-#define NALL_QT_FILEDIALOG_HPP
-
-#include <nall/platform.hpp>
-#include <nall/string.hpp>
-#include <nall/qt/window.moc.hpp>
-
-namespace nall {
-
-class FileDialog;
-
-class NewFolderDialog : public Window {
-  Q_OBJECT
-
-public:
-  void show();
-  NewFolderDialog(FileDialog*);
-
-protected slots:
-  void createFolderAction();
-
-protected:
-  FileDialog *parent;
-  QVBoxLayout *layout;
-  QLineEdit *folderNameEdit;
-  QHBoxLayout *controlLayout;
-  QPushButton *okButton;
-  QPushButton *cancelButton;
-};
-
-class FileView : public QListView {
-  Q_OBJECT
-
-protected:
-  void keyPressEvent(QKeyEvent*);
-
-signals:
-  void changed(const QModelIndex&);
-  void browseUp();
-
-protected slots:
-  void currentChanged(const QModelIndex&, const QModelIndex&);
-};
-
-class FileDialog : public Window {
-  Q_OBJECT
-
-public:
-  void showLoad();
-  void showSave();
-  void showFolder();
-
-  void setPath(string path);
-  void setNameFilters(const string &filters);
-  FileDialog();
-
-signals:
-  void changed(const string&);
-  void activated(const string&);
-  void accepted(const string&);
-  void rejected();
-
-protected slots:
-  void fileViewChange(const QModelIndex&);
-  void fileViewActivate(const QModelIndex&);
-  void pathBoxChanged();
-  void filterBoxChanged();
-  void createNewFolder();
-  void browseUp();
-  void acceptAction();
-  void rejectAction();
-
-protected:
-  NewFolderDialog *newFolderDialog;
-  QVBoxLayout *layout;
-  QHBoxLayout *navigationLayout;
-  QComboBox *pathBox;
-  QPushButton *newFolderButton;
-  QPushButton *upFolderButton;
-  QHBoxLayout *browseLayout;
-  QFileSystemModel *fileSystemModel;
-  FileView *fileView;
-  QGroupBox *previewFrame;
-  QLineEdit *fileNameEdit;
-  QHBoxLayout *controlLayout;
-  QComboBox *filterBox;
-  QPushButton *optionsButton;
-  QPushButton *acceptButton;
-  QPushButton *rejectButton;
-  bool lock;
-  void createFolderAction(const string &name);
-  void closeEvent(QCloseEvent*);
-
-  friend class NewFolderDialog;
-};
-
-inline void NewFolderDialog::show() {
-  folderNameEdit->setText("");
-  Window::show();
-  folderNameEdit->setFocus();
-}
-
-inline void NewFolderDialog::createFolderAction() {
-  string name = folderNameEdit->text().toUtf8().constData();
-  if(name == "") {
-    folderNameEdit->setFocus();
-  } else {
-    parent->createFolderAction(name);
-    close();
-  }
-}
-
-inline NewFolderDialog::NewFolderDialog(FileDialog *fileDialog) : parent(fileDialog) {
-  setMinimumWidth(240);
-  setWindowTitle("Create New Folder");
-
-  layout = new QVBoxLayout;
-  layout->setAlignment(Qt::AlignTop);
-  layout->setMargin(5);
-  layout->setSpacing(5);
-  setLayout(layout);
-
-  folderNameEdit = new QLineEdit;
-  layout->addWidget(folderNameEdit);
-
-  controlLayout = new QHBoxLayout;
-  controlLayout->setAlignment(Qt::AlignRight);
-  layout->addLayout(controlLayout);
-
-  okButton = new QPushButton("Ok");
-  controlLayout->addWidget(okButton);
-
-  cancelButton = new QPushButton("Cancel");
-  controlLayout->addWidget(cancelButton);
-
-  connect(folderNameEdit, SIGNAL(returnPressed()), this, SLOT(createFolderAction()));
-  connect(okButton, SIGNAL(released()), this, SLOT(createFolderAction()));
-  connect(cancelButton, SIGNAL(released()), this, SLOT(close()));
-}
-
-inline void FileView::currentChanged(const QModelIndex &current, const QModelIndex &previous) {
-  QAbstractItemView::currentChanged(current, previous);
-  emit changed(current);
-}
-
-inline void FileView::keyPressEvent(QKeyEvent *event) {
-  //enhance consistency: force OS X to act like Windows and Linux; enter = activate item
-  if(event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) {
-    emit activated(currentIndex());
-    return;
-  }
-
-  //simulate popular file manager behavior; backspace = go up one directory
-  if(event->key() == Qt::Key_Backspace) {
-    emit browseUp();
-    return;
-  }
-
-  //fallback: unrecognized keypresses get handled by the widget itself
-  QListView::keyPressEvent(event);
-}
-
-inline void FileDialog::showLoad() {
-  acceptButton->setText("Load");
-  fileNameEdit->hide();
-  filterBox->show();
-  show();
-}
-
-inline void FileDialog::showSave() {
-  acceptButton->setText("Save");
-  fileNameEdit->show();
-  filterBox->show();
-  show();
-}
-
-inline void FileDialog::showFolder() {
-  acceptButton->setText("Choose");
-  fileNameEdit->hide();
-  filterBox->hide();
-  setNameFilters("Folders ()");
-  show();
-}
-
-inline void FileDialog::fileViewChange(const QModelIndex &index) {
-  string path = fileSystemModel->filePath(index).toUtf8().constData();
-  if(path == fileSystemModel->rootPath().toUtf8().constData()) path = "";
-  fileNameEdit->setText(notdir(path));
-  emit changed(path);
-}
-
-inline void FileDialog::fileViewActivate(const QModelIndex &index) {
-  string path = fileSystemModel->filePath(index).toUtf8().constData();
-  if(fileSystemModel->isDir(index)) {
-    emit activated(path);
-    setPath(path);
-  } else {
-    emit activated(path);
-    close();
-  }
-}
-
-inline void FileDialog::pathBoxChanged() {
-  if(lock) return;
-  setPath(pathBox->currentText().toUtf8().constData());
-}
-
-inline void FileDialog::filterBoxChanged() {
-  if(lock) return;
-  string filters = filterBox->currentText().toUtf8().constData();
-  if(filters.length() == 0) {
-    fileSystemModel->setNameFilters(QStringList() << "*");
-  } else {
-    filters = substr(filters, strpos(filters, "(")());
-    filters.ltrim("(");
-    filters.rtrim(")");
-    lstring part;
-    part.split(" ", filters);
-    QStringList list;
-    for(unsigned i = 0; i < part.size(); i++) list << part[i];
-    fileSystemModel->setNameFilters(list);
-  }
-}
-
-inline void FileDialog::createNewFolder() {
-  newFolderDialog->show();
-}
-
-inline void FileDialog::browseUp() {
-  if(pathBox->count() > 1) pathBox->setCurrentIndex(1);
-}
-
-inline void FileDialog::setPath(string path) {
-  lock = true;
-  newFolderDialog->close();
-
-  if(QDir(path).exists()) {
-    newFolderButton->setEnabled(true);
-  } else {
-    newFolderButton->setEnabled(false);
-    path = "";
-  }
-
-  fileSystemModel->setRootPath(path);
-  fileView->setRootIndex(fileSystemModel->index(path));
-  fileView->setCurrentIndex(fileView->rootIndex());
-  fileView->setFocus();
-
-  pathBox->clear();
-  if(path.length() > 0) {
-    QDir directory(path);
-    while(true) {
-      pathBox->addItem(directory.absolutePath());
-      if(directory.isRoot()) break;
-      directory.cdUp();
-    }
-  }
-  pathBox->addItem("<root>");
-  fileNameEdit->setText("");
-
-  lock = false;
-}
-
-inline void FileDialog::setNameFilters(const string &filters) {
-  lock = true;
-
-  lstring list;
-  list.split("\n", filters);
-
-  filterBox->clear();
-  for(unsigned i = 0; i < list.size(); i++) {
-    filterBox->addItem(list[i]);
-  }
-
-  lock = false;
-  filterBoxChanged();
-}
-
-inline void FileDialog::acceptAction() {
-  string path = fileSystemModel->rootPath().toUtf8().constData();
-  path << "/" << notdir(fileNameEdit->text().toUtf8().constData());
-  path.rtrim("/");
-  if(QDir(path).exists()) {
-    emit accepted(path);
-    setPath(path);
-  } else {
-    emit accepted(path);
-    close();
-  }
-}
-
-inline void FileDialog::rejectAction() {
-  emit rejected();
-  close();
-}
-
-inline void FileDialog::createFolderAction(const string &name) {
-  string path = fileSystemModel->rootPath().toUtf8().constData();
-  path << "/" << notdir(name);
-  mkdir(path, 0755);
-}
-
-inline void FileDialog::closeEvent(QCloseEvent *event) {
-  newFolderDialog->close();
-  Window::closeEvent(event);
-}
-
-inline FileDialog::FileDialog() {
-  newFolderDialog = new NewFolderDialog(this);
-  resize(640, 360);
-
-  layout = new QVBoxLayout;
-  layout->setMargin(5);
-  layout->setSpacing(5);
-  setLayout(layout);
-
-  navigationLayout = new QHBoxLayout;
-  layout->addLayout(navigationLayout);
-
-  pathBox = new QComboBox;
-  pathBox->setEditable(true);
-  pathBox->setMinimumContentsLength(16);
-  pathBox->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
-  pathBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
-  navigationLayout->addWidget(pathBox);
-
-  newFolderButton = new QPushButton;
-  newFolderButton->setIconSize(QSize(16, 16));
-  newFolderButton->setIcon(QIcon(":/16x16/folder-new.png"));
-  navigationLayout->addWidget(newFolderButton);
-
-  upFolderButton = new QPushButton;
-  upFolderButton->setIconSize(QSize(16, 16));
-  upFolderButton->setIcon(QIcon(":/16x16/go-up.png"));
-  navigationLayout->addWidget(upFolderButton);
-
-  browseLayout = new QHBoxLayout;
-  layout->addLayout(browseLayout);
-
-  fileSystemModel = new QFileSystemModel;
-  fileSystemModel->setFilter(QDir::AllDirs | QDir::Files | QDir::NoDotAndDotDot);
-  fileSystemModel->setNameFilterDisables(false);
-
-  fileView = new FileView;
-  fileView->setMinimumWidth(320);
-  fileView->setModel(fileSystemModel);
-  fileView->setIconSize(QSize(16, 16));
-  browseLayout->addWidget(fileView);
-
-  previewFrame = new QGroupBox;
-  previewFrame->hide();
-  browseLayout->addWidget(previewFrame);
-
-  fileNameEdit = new QLineEdit;
-  layout->addWidget(fileNameEdit);
-
-  controlLayout = new QHBoxLayout;
-  controlLayout->setAlignment(Qt::AlignRight);
-  layout->addLayout(controlLayout);
-
-  filterBox = new QComboBox;
-  filterBox->setMinimumContentsLength(16);
-  filterBox->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
-  filterBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
-  controlLayout->addWidget(filterBox);
-
-  optionsButton = new QPushButton("Options");
-  optionsButton->hide();
-  controlLayout->addWidget(optionsButton);
-
-  acceptButton = new QPushButton("Ok");
-  controlLayout->addWidget(acceptButton);
-
-  rejectButton = new QPushButton("Cancel");
-  controlLayout->addWidget(rejectButton);
-
-  lock = false;
-  connect(pathBox, SIGNAL(currentIndexChanged(int)), this, SLOT(pathBoxChanged()));
-  connect(newFolderButton, SIGNAL(released()), this, SLOT(createNewFolder()));
-  connect(upFolderButton, SIGNAL(released()), this, SLOT(browseUp()));
-  connect(fileView, SIGNAL(changed(const QModelIndex&)), this, SLOT(fileViewChange(const QModelIndex&)));
-  connect(fileView, SIGNAL(activated(const QModelIndex&)), this, SLOT(fileViewActivate(const QModelIndex&)));
-  connect(fileView, SIGNAL(browseUp()), this, SLOT(browseUp()));
-  connect(fileNameEdit, SIGNAL(returnPressed()), this, SLOT(acceptAction()));
-  connect(filterBox, SIGNAL(currentIndexChanged(int)), this, SLOT(filterBoxChanged()));
-  connect(acceptButton, SIGNAL(released()), this, SLOT(acceptAction()));
-  connect(rejectButton, SIGNAL(released()), this, SLOT(rejectAction()));
-}
-
-}
-
-#endif

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

@@ -1,173 +0,0 @@
-#ifndef NALL_QT_HEXEDITOR_HPP
-#define NALL_QT_HEXEDITOR_HPP
-
-#include <nall/function.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-
-namespace nall {
-
-class HexEditor : public QTextEdit {
-  Q_OBJECT
-
-public:
-  function<uint8_t (unsigned)> reader;
-  function<void (unsigned, uint8_t)> writer;
-
-  void setColumns(unsigned columns);
-  void setRows(unsigned rows);
-  void setOffset(unsigned offset);
-  void setSize(unsigned size);
-  unsigned lineWidth() const;
-  void refresh();
-
-  HexEditor();
-
-protected slots:
-  void scrolled();
-
-protected:
-  QHBoxLayout *layout;
-  QScrollBar *scrollBar;
-  unsigned editorColumns;
-  unsigned editorRows;
-  unsigned editorOffset;
-  unsigned editorSize;
-  bool lock;
-
-  void keyPressEvent(QKeyEvent*);
-};
-
-inline void HexEditor::keyPressEvent(QKeyEvent *event) {
-  QTextCursor cursor = textCursor();
-  unsigned x = cursor.position() % lineWidth();
-  unsigned y = cursor.position() / lineWidth();
-
-  int hexCode = -1;
-  switch(event->key()) {
-    case Qt::Key_0: hexCode =  0; break;
-    case Qt::Key_1: hexCode =  1; break;
-    case Qt::Key_2: hexCode =  2; break;
-    case Qt::Key_3: hexCode =  3; break;
-    case Qt::Key_4: hexCode =  4; break;
-    case Qt::Key_5: hexCode =  5; break;
-    case Qt::Key_6: hexCode =  6; break;
-    case Qt::Key_7: hexCode =  7; break;
-    case Qt::Key_8: hexCode =  8; break;
-    case Qt::Key_9: hexCode =  9; break;
-    case Qt::Key_A: hexCode = 10; break;
-    case Qt::Key_B: hexCode = 11; break;
-    case Qt::Key_C: hexCode = 12; break;
-    case Qt::Key_D: hexCode = 13; break;
-    case Qt::Key_E: hexCode = 14; break;
-    case Qt::Key_F: hexCode = 15; break;
-  }
-
-  if(cursor.hasSelection() == false && hexCode != -1) {
-    bool cursorOffsetValid = (x >= 11 && ((x - 11) % 3) != 2);
-    if(cursorOffsetValid) {
-      bool nibble = (x - 11) % 3;  //0 = top nibble, 1 = bottom nibble
-      unsigned cursorOffset = y * editorColumns + ((x - 11) / 3);
-      unsigned effectiveOffset = editorOffset + cursorOffset;
-      if(effectiveOffset >= editorSize) effectiveOffset %= editorSize;
-
-      uint8_t data = reader ? reader(effectiveOffset) : 0x00;
-      data &= (nibble == 0 ? 0x0f : 0xf0);
-      data |= (nibble == 0 ? (hexCode << 4) : (hexCode << 0));
-      if(writer) writer(effectiveOffset, data);
-      refresh();
-
-      cursor.setPosition(y * lineWidth() + x + 1);  //advance cursor
-      setTextCursor(cursor);
-    }
-  } else {
-    //allow navigation keys to move cursor, but block text input
-    setTextInteractionFlags(Qt::TextSelectableByKeyboard | Qt::TextSelectableByMouse);
-    QTextEdit::keyPressEvent(event);
-    setTextInteractionFlags(Qt::TextEditorInteraction);
-  }
-}
-
-inline void HexEditor::setColumns(unsigned columns) {
-  editorColumns = columns;
-}
-
-inline void HexEditor::setRows(unsigned rows) {
-  editorRows = rows;
-  scrollBar->setPageStep(editorRows);
-}
-
-inline void HexEditor::setOffset(unsigned offset) {
-  lock = true;
-  editorOffset = offset;
-  scrollBar->setSliderPosition(editorOffset / editorColumns);
-  lock = false;
-}
-
-inline void HexEditor::setSize(unsigned size) {
-  editorSize = size;
-  bool indivisible = (editorSize % editorColumns) != 0;  //add one for incomplete row
-  scrollBar->setRange(0, editorSize / editorColumns + indivisible - editorRows);
-}
-
-inline unsigned HexEditor::lineWidth() const {
-  return 11 + 3 * editorColumns;
-}
-
-inline void HexEditor::refresh() {
-  string output;
-  char temp[256];
-  unsigned offset = editorOffset;
-
-  for(unsigned y = 0; y < editorRows; y++) {
-    if(offset >= editorSize) break;
-    sprintf(temp, "%.4x:%.4x", (offset >> 16) & 0xffff, (offset >> 0) & 0xffff);
-    output << "<font color='#808080'>" << temp << "</font>&nbsp;&nbsp;";
-
-    for(unsigned x = 0; x < editorColumns; x++) {
-      if(offset >= editorSize) break;
-      sprintf(temp, "%.2x", reader ? reader(offset) : 0x00);
-      offset++;
-      output << "<font color='" << ((x & 1) ? "#000080" : "#0000ff") << "'>" << temp << "</font>";
-      if(x != (editorColumns - 1)) output << "&nbsp;";
-    }
-
-    if(y != (editorRows - 1)) output << "<br>";
-  }
-
-  setHtml(output);
-}
-
-inline void HexEditor::scrolled() {
-  if(lock) return;
-  unsigned offset = scrollBar->sliderPosition();
-  editorOffset = offset * editorColumns;
-  refresh();
-}
-
-inline HexEditor::HexEditor() {
-  setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-  setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-
-  layout = new QHBoxLayout;
-  layout->setAlignment(Qt::AlignRight);
-  layout->setMargin(0);
-  layout->setSpacing(0);
-  setLayout(layout);
-
-  scrollBar = new QScrollBar(Qt::Vertical);
-  scrollBar->setSingleStep(1);
-  layout->addWidget(scrollBar);
-
-  lock = false;
-  connect(scrollBar, SIGNAL(actionTriggered(int)), this, SLOT(scrolled()));
-
-  setColumns(16);
-  setRows(16);
-  setSize(0);
-  setOffset(0);
-}
-
-}
-
-#endif

bsnes/nall/qt/radio-action.moc.hpp

@@ -1,41 +0,0 @@
-#ifndef NALL_QT_RADIOACTION_HPP
-#define NALL_QT_RADIOACTION_HPP
-
-namespace nall {
-
-class RadioAction : public QAction {
-  Q_OBJECT
-
-public:
-  bool isChecked() const;
-  void setChecked(bool);
-  void toggleChecked();
-  RadioAction(const QString&, QObject*);
-
-protected slots:
-
-protected:
-  bool checked;
-};
-
-inline bool RadioAction::isChecked() const {
-  return checked;
-}
-
-inline void RadioAction::setChecked(bool checked_) {
-  checked = checked_;
-  if(checked) setIcon(QIcon(":/16x16/item-radio-on.png"));
-  else setIcon(QIcon(":/16x16/item-radio-off.png"));
-}
-
-inline void RadioAction::toggleChecked() {
-  setChecked(!isChecked());
-}
-
-inline RadioAction::RadioAction(const QString &text, QObject *parent) : QAction(text, parent) {
-  setChecked(false);
-}
-
-}
-
-#endif

bsnes/nall/qt/window.moc.hpp

@@ -1,105 +0,0 @@
-#ifndef NALL_QT_WINDOW_HPP
-#define NALL_QT_WINDOW_HPP
-
-#include <nall/base64.hpp>
-#include <nall/string.hpp>
-
-namespace nall {
-
-class Window : public QWidget {
-  Q_OBJECT
-
-public:
-  void setGeometryString(string *geometryString);
-  void setCloseOnEscape(bool);
-  void show();
-  void hide();
-  void shrink();
-
-  Window();
-
-protected slots:
-
-protected:
-  string *geometryString;
-  bool closeOnEscape;
-  void keyReleaseEvent(QKeyEvent *event);
-  void closeEvent(QCloseEvent *event);
-};
-
-inline void Window::setGeometryString(string *geometryString_) {
-  geometryString = geometryString_;
-  if(geometryString && isVisible() == false) {
-    uint8_t *data;
-    unsigned length;
-    base64::decode(data, length, *geometryString);
-    QByteArray array((const char*)data, length);
-    delete[] data;
-    restoreGeometry(array);
-  }
-}
-
-inline void Window::setCloseOnEscape(bool value) {
-  closeOnEscape = value;
-}
-
-inline void Window::show() {
-  if(geometryString && isVisible() == false) {
-    uint8_t *data;
-    unsigned length;
-    base64::decode(data, length, *geometryString);
-    QByteArray array((const char*)data, length);
-    delete[] data;
-    restoreGeometry(array);
-  }
-  QWidget::show();
-  QApplication::processEvents();
-  activateWindow();
-  raise();
-}
-
-inline void Window::hide() {
-  if(geometryString && isVisible() == true) {
-    char *data;
-    QByteArray geometry = saveGeometry();
-    base64::encode(data, (const uint8_t*)geometry.data(), geometry.length());
-    *geometryString = data;
-    delete[] data;
-  }
-  QWidget::hide();
-}
-
-inline void Window::shrink() {
-  if(isFullScreen()) return;
-
-  for(unsigned i = 0; i < 2; i++) {
-    resize(0, 0);
-    usleep(2000);
-    QApplication::processEvents();
-  }
-}
-
-inline void Window::keyReleaseEvent(QKeyEvent *event) {
-  if(closeOnEscape && (event->key() == Qt::Key_Escape)) close();
-  QWidget::keyReleaseEvent(event);
-}
-
-inline void Window::closeEvent(QCloseEvent *event) {
-  if(geometryString) {
-    char *data;
-    QByteArray geometry = saveGeometry();
-    base64::encode(data, (const uint8_t*)geometry.data(), geometry.length());
-    *geometryString = data;
-    delete[] data;
-  }
-  QWidget::closeEvent(event);
-}
-
-inline Window::Window() {
-  geometryString = 0;
-  closeOnEscape = true;
-}
-
-}
-
-#endif

bsnes/nall/random.hpp

@@ -8,12 +8,20 @@ namespace nall {
     return n = (n >> 1) ^ (((n & 1) - 1) & 0xedb88320);
   }
 
-  struct random_cyclic {
-    unsigned seed;
-    inline unsigned operator()() {
-      return seed = (seed >> 1) ^ (((seed & 1) - 1) & 0xedb88320);
+  struct random_lfsr {
+    inline void seed(unsigned seed__) {
+      seed_ = seed__;
     }
-    random_cyclic() : seed(0) {}
+
+    inline unsigned operator()() {
+      return seed_ = (seed_ >> 1) ^ (((seed_ & 1) - 1) & 0xedb88320);
+    }
+
+    random_lfsr() : seed_(0) {
+    }
+
+  private:
+    unsigned seed_;
   };
 }