Update to bsnes v040 release.

Too much to really name. The biggest news is that the entire user interface has been re-written from scratch. It is now far more polished and professional. To name one example; the cheat code editor now has checkboxes in the list to quickly toggle codes on an off, there is now a global hotkey to toggle all cheat codes, and each cheat code can contain multiple individual Game Genie or Pro Action Replay codes, allowing easy grouping of multi-part codes.
You'll also notice new artwork: a logo created by Derrick Sobodash (note that the logo contest from below is still active — if someone can design a better logo, it can appear in v041), and a new photo-realistic SNES controller graphic by FirebrandX.
I was finally able to utilize MinGW's profile-guided optimizations, which means this release is approximately ~12% faster than v039.
And emulation itself was even improved(!), such as with Jonas Quinn's fix for a sprite overflow bug.
There were many other changes as well: Linux users will be happy to see RGB overlay support for the X-Video driver, many will benefit from greatly enhanced warning messages and tooltips throughout the GUI, Windows users will now be able to access the menu without freezing emulation, etc etc.

src/Makefile

@@ -1,29 +1,40 @@
 include lib/nall/Makefile.string
 prefix = /usr/local
+ui = ui_qt
 
 ################
 ### compiler ###
 ################
 
 ifneq ($(findstring gcc,$(compiler)),) # GCC family
-  flags = -O3 -fomit-frame-pointer $(if $(call streq,$(platform),x),-mtune=native,) -Ilib
-  c = $(compiler) $(flags)
-  cpp = $(subst cc,++,$(compiler)) $(flags)
+  flags = -O3 -fomit-frame-pointer -Ilib
+  # note: libco *requires* -fomit-frame-pointer on i386 arch
+  libcoflags := $(flags) -static
+  c = $(compiler)
+  cpp = $(subst cc,++,$(compiler))
   obj = o
   rule = -c $< -o $@
   link = -s
   mkbin = -o$1
   mkdef = -D$1
+  mkinc = -I$1
   mklib = -l$1
+
+  # profile-guided optimization:
+  # flags += -fprofile-generate
+  # link += -lgcov
+  # flags += -fprofile-use
 else ifeq ($(compiler),cl) # Visual C++
-  flags = /nologo /wd4355 /wd4996 /O2 /EHsc /Ilib
-  c = cl $(flags)
-  cpp = cl $(flags)
+  flags = /nologo /wd4355 /wd4805 /wd4996 /Ox /GL /EHsc /Ilib
+  libcoflags = $(flags)
+  c = cl
+  cpp = cl
   obj = obj
   rule = /c $< /Fo$@
   link = /link
   mkbin = /Fe$1
   mkdef = /D$1
+  mkinc = /I$1
   mklib = $1.lib
 else
   unknown_compiler: help;
@@ -35,21 +46,19 @@ endif
 
 ifeq ($(platform),x) # X11
   ruby = video.glx video.xv video.sdl audio.alsa audio.openal audio.oss audio.pulseaudio audio.ao input.sdl input.x
-  link += `pkg-config --libs gtk+-2.0`
-  link += $(call mklib,Xtst)
   delete = rm -f $1
 else ifeq ($(platform),win) # Windows
+  # enable static linking to Qt for Windows build
+  mingw_link_flags = -mwindows -enable-stdcall-fixup -Wl,-s -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc
+
   ruby = video.direct3d video.wgl video.directdraw video.gdi audio.directsound input.directinput
-  link += $(if $(findstring mingw,$(compiler)),-mwindows)
+  delete = $(if $(findstring i586-mingw-gcc,$(compiler)),rm -f $1,del $(subst /,\,$1))
+  link += $(if $(findstring mingw,$(compiler)),$(mingw_link_flags))
   link += $(call mklib,uuid)
   link += $(call mklib,kernel32)
   link += $(call mklib,user32)
   link += $(call mklib,gdi32)
   link += $(call mklib,shell32)
-  link += $(call mklib,winmm)
-  link += $(call mklib,comdlg32)
-  link += $(call mklib,comctl32)
-  delete = $(if $(findstring i586-mingw-gcc,$(compiler)),rm -f $1,del $(subst /,\,$1))
 else
   unknown_platform: help;
 endif
@@ -58,8 +67,7 @@ endif
 ### ruby ###
 ############
 
-rubyflags =
-rubyflags += $(if $(findstring .sdl,$(ruby)),`sdl-config --cflags`)
+rubyflags = $(if $(findstring .sdl,$(ruby)),`sdl-config --cflags`)
 
 link += $(if $(findstring video.direct3d,$(ruby)),$(call mklib,d3d9))
 link += $(if $(findstring video.directdraw,$(ruby)),$(call mklib,ddraw))
@@ -74,12 +82,12 @@ link += $(if $(findstring audio.pulseaudio,$(ruby)),$(call mklib,pulse-simple))
 link += $(if $(findstring input.directinput,$(ruby)),$(call mklib,dinput8) $(call mklib,dxguid))
 link += $(if $(findstring input.sdl,$(ruby)),`sdl-config --libs`)
 
-####################################
-### main target and dependencies ###
-####################################
+####################
+### core objects ###
+####################
 
-objects = main libco hiro ruby libfilter string \
-  config reader cart cheat \
+objects = libco ruby libfilter string \
+  reader cart cheat \
   memory smemory cpu scpu smp ssmp sdsp ppu bppu snes \
   bsx srtc sdd1 spc7110 cx4 dsp1 dsp2 dsp3 dsp4 obc1 st010
 
@@ -93,43 +101,27 @@ ifeq ($(enable_jma),true)
   flags += $(call mkdef,JMA_SUPPORT)
 endif
 
-objects := $(patsubst %,obj/%.$(obj),$(objects))
-rubydef := $(foreach c,$(subst .,_,$(call strupper,$(ruby))),$(call mkdef,$c))
-
-# Windows resource file
-ifeq ($(platform),win)
-  ifeq ($(compiler),cl)
-    objects += obj/bsnes.res
-  else ifneq ($(findstring gcc,$(compiler)),)
-    objects += obj/bsnesrc.$(obj)
-  endif
-endif
-
-################
-### implicit ###
-################
+######################
+### implicit rules ###
+######################
 
 compile = \
   $(strip \
     $(if $(filter %.c,$<), \
-      $(c) $1 $(rule), \
+      $(c) $(flags) $1 $(rule), \
       $(if $(filter %.cpp,$<), \
-        $(cpp) $1 $(rule) \
+        $(cpp) $(flags) $1 $(rule) \
       ) \
     ) \
   )
 
-%.$(obj): $<; $(call compile)
+%.$(obj): $<;	$(call compile)
 
 all: build;
 
-############
-### main ###
-############
-
-obj/main.$(obj): ui/main.cpp ui/* ui/base/* ui/event/* ui/loader/* ui/settings/*
-obj/bsnes.res: ui/bsnes.rc; rc /r /foobj/bsnes.res ui/bsnes.rc
-obj/bsnesrc.$(obj): ui/bsnes.rc; windres ui/bsnes.rc obj/bsnesrc.$(obj)
+include $(ui)/Makefile
+objects := $(patsubst %,obj/%.$(obj),$(objects))
+rubydef := $(foreach c,$(subst .,_,$(call strupper,$(ruby))),$(call mkdef,$c))
 
 #################
 ### libraries ###
@@ -137,18 +129,15 @@ obj/bsnesrc.$(obj): ui/bsnes.rc; windres ui/bsnes.rc obj/bsnesrc.$(obj)
 
 obj/ruby.$(obj): lib/ruby/ruby.cpp lib/ruby/* lib/ruby/video/* lib/ruby/audio/* lib/ruby/input/*
 	$(call compile,$(rubydef) $(rubyflags))
-obj/hiro.$(obj): lib/hiro/hiro.cpp lib/hiro/* lib/hiro/gtk/* lib/hiro/win/*
-	$(call compile,$(if $(call streq,$(platform),x),`pkg-config --cflags gtk+-2.0`))
-obj/libco.$(obj):     lib/libco/libco.c lib/libco/*
-	$(call compile,-static)
+obj/libco.$(obj): lib/libco/libco.c lib/libco/*
+	$(c) $(libcoflags) $(rule)
 obj/libfilter.$(obj): lib/libfilter/libfilter.cpp lib/libfilter/*
-obj/string.$(obj):    lib/nall/string.cpp lib/nall/*
+obj/string.$(obj): lib/nall/string.cpp lib/nall/*
 
 #################
 ### utilities ###
 #################
 
-obj/config.$(obj): config/config.cpp config/*
 obj/reader.$(obj): reader/reader.cpp reader/*
 obj/cart.$(obj)  : cart/cart.cpp cart/*
 obj/cheat.$(obj) : cheat/cheat.cpp cheat/*
@@ -245,14 +234,15 @@ obj/winout.$(obj) : reader/jma/winout.cpp reader/jma/*
 ### targets ###
 ###############
 
-build: $(objects)
+build: ui_build $(objects)
 	$(strip $(cpp) $(call mkbin,../bsnes) $(objects) $(link))
 
 install:
 	install -D -m 755 ../bsnes $(DESTDIR)$(prefix)/bin/bsnes
-	install -D -m 644 data/bsnes.png $(DESTDIR)$(prefix)/share/icons/bsnes.png
+	install -D -m 644 data/bsnes.png $(DESTDIR)$(prefix)/share/pixmaps/bsnes.png
+	install -D -m 644 data/bsnes.desktop $(DESTDIR)$(prefix)/share/applications/bsnes.desktop
 
-clean:
+clean: ui_clean
 	-@$(call delete,obj/*.$(obj))
 	-@$(call delete,*.res)
 	-@$(call delete,*.pgd)

src/base.hpp

@@ -1,4 +1,4 @@
-#define BSNES_VERSION "0.038"
+#define BSNES_VERSION "0.040"
 #define BSNES_TITLE   "bsnes v" BSNES_VERSION
 
 #define BUSCORE sBus
@@ -24,15 +24,13 @@
 #include <nall/algorithm.hpp>
 #include <nall/array.hpp>
 #include <nall/bit.hpp>
-#include <nall/config.hpp>
 #include <nall/detect.hpp>
 #include <nall/endian.hpp>
 #include <nall/file.hpp>
-#include <nall/function.hpp>
-#include <nall/modulo.hpp>
+#include <nall/moduloarray.hpp>
 #include <nall/new.hpp>
 #include <nall/platform.hpp>
-#include <nall/sort.hpp>
+#include <nall/property.hpp>
 #include <nall/stdint.hpp>
 #include <nall/string.hpp>
 #include <nall/utility.hpp>
@@ -47,6 +45,5 @@ typedef uint8_t  uint8;
 typedef uint16_t uint16;
 typedef uint32_t uint32;
 typedef uint64_t uint64;
-typedef unsigned uint;
 
 #include "interface.hpp"

src/cart/cart.cpp

@@ -1,17 +1,15 @@
-#include <../base.hpp>
-#define CART_CPP
-
-#include <nall/crc32.hpp>
+#include <../base.hpp>
+#include <../chip/chip.hpp>
+#include <../reader/reader.hpp>
+#define CART_CPP
+
+#include <nall/crc32.hpp>
 #include <nall/ups.hpp>
 
-#include "cart_load.cpp"
-#include "cart_normal.cpp"
-#include "cart_bsx.cpp"
-#include "cart_bsc.cpp"
-#include "cart_st.cpp"
-
+#include "cart.hpp"
 #include "cart_file.cpp"
 #include "cart_header.cpp"
+#include "cart_loader.cpp"
 
 namespace memory {
   MappedRAM cartrom, cartram, cartrtc;
@@ -22,13 +20,7 @@ namespace memory {
 
 Cartridge cartridge;
 
-const char* Cartridge::name() { return info.filename; }
-Cartridge::CartridgeMode Cartridge::mode() { return info.mode; }
-Cartridge::MemoryMapper Cartridge::mapper() { return info.mapper; }
-Cartridge::Region Cartridge::region() { return info.region; }
-bool Cartridge::loaded() { return cart.loaded; }
-
-void Cartridge::load_begin(CartridgeMode mode) {
+void Cartridge::load_begin(Mode cartridge_mode) {
   cart.rom = cart.ram = cart.rtc = 0;
   bs.ram   = 0;
   stA.rom  = stA.ram  = 0;
@@ -39,11 +31,10 @@ void Cartridge::load_begin(CartridgeMode mode) {
   stA.rom_size  = stA.ram_size  = 0;
   stB.rom_size  = stB.ram_size  = 0;
 
-  info.mode = mode;
-  info.patched = false;
-
-  info.bsxcart  = false;
-  info.bsxflash = false;
+  set(loaded,           false);
+  set(bsx_flash_loaded, false);
+  set(patched,          false);
+  set(mode,             cartridge_mode);
 }
 
 void Cartridge::load_end() {
@@ -64,25 +55,25 @@ void Cartridge::load_end() {
   memory::stBrom.write_protect(true);
   memory::stBram.write_protect(false);
 
-  if(file::exists(get_cheat_filename(cart.fn, "cht"))) {
+  string cheat_file = get_filename(cart.filename, "cht", snes.config.path.cheat);
+  if(file::exists(cheat_file)) {
     cheat.clear();
-    cheat.load(cheatfn);
+    cheat.load(cheat_file);
   }
 
-  cart.loaded = true;
   bus.load_cart();
+  set(loaded, true);
 }
 
-bool Cartridge::unload() {
-  if(cart.loaded == false) return false;
-
+void Cartridge::unload() {
+  if(loaded() == false) return;
   bus.unload_cart();
 
-  switch(info.mode) {
-    case ModeNormal:      unload_cart_normal(); break;
-    case ModeBSX:         unload_cart_bsx();    break;
-    case ModeBSC:         unload_cart_bsc();    break;
-    case ModeSufamiTurbo: unload_cart_st();     break;
+  switch(mode()) {
+    case ModeNormal:      unload_normal();       break;
+    case ModeBsxSlotted:  unload_bsx_slotted();  break;
+    case ModeBsx:         unload_bsx();          break;
+    case ModeSufamiTurbo: unload_sufami_turbo(); break;
   }
 
   if(cart.rom) { delete[] cart.rom; cart.rom = 0; }
@@ -94,24 +85,49 @@ bool Cartridge::unload() {
   if(stB.rom)  { delete[] stB.rom;  stB.rom  = 0; }
   if(stB.ram)  { delete[] stB.ram;  stB.ram  = 0; }
 
-  if(cheat.count() > 0 || file::exists(get_cheat_filename(cart.fn, "cht"))) {
-    cheat.save(cheatfn);
+  string cheat_file = get_filename(cart.filename, "cht", snes.config.path.cheat);
+  if(cheat.count() > 0 || file::exists(cheat_file)) {
+    cheat.save(cheat_file);
     cheat.clear();
   }
 
-  cart.loaded = false;
-  return true;
+  set(loaded, false);
 }
 
 Cartridge::Cartridge() {
-  cart.loaded = false;
+  set(loaded, false);
 }
 
 Cartridge::~Cartridge() {
-  if(cart.loaded == true) unload();
+  if(loaded() == true) unload();
 }
 
-//
+void Cartridge::set_cartinfo(const Cartridge::cartinfo_t &source) {
+  set(region,         source.region);
+  set(mapper,         source.mapper);
+  set(dsp1_mapper,    source.dsp1_mapper);
+
+  set(has_bsx_slot,   source.bsx_slot);
+  set(has_superfx,    source.superfx);
+  set(has_sa1,        source.sa1);
+  set(has_srtc,       source.srtc);
+  set(has_sdd1,       source.sdd1);
+  set(has_spc7110,    source.spc7110);
+  set(has_spc7110rtc, source.spc7110rtc);
+  set(has_cx4,        source.cx4);
+  set(has_dsp1,       source.dsp1);
+  set(has_dsp2,       source.dsp2);
+  set(has_dsp3,       source.dsp3);
+  set(has_dsp4,       source.dsp4);
+  set(has_obc1,       source.obc1);
+  set(has_st010,      source.st010);
+  set(has_st011,      source.st011);
+  set(has_st018,      source.st018);
+}
+
+//==========
+//cartinfo_t
+//==========
 
 void Cartridge::cartinfo_t::reset() {
   type        = TypeUnknown;
@@ -122,7 +138,7 @@ void Cartridge::cartinfo_t::reset() {
   rom_size = 0;
   ram_size = 0;
 
-  bsxslot    = false;
+  bsx_slot   = false;
   superfx    = false;
   sa1        = false;
   srtc       = false;
@@ -140,28 +156,79 @@ void Cartridge::cartinfo_t::reset() {
   st018      = false;
 }
 
-//apply cart-specific settings to current cartridge mode settings
-Cartridge::info_t& Cartridge::info_t::operator=(const Cartridge::cartinfo_t &source) {
-  mapper      = source.mapper;
-  dsp1_mapper = source.dsp1_mapper;
-  region      = source.region;
-
-  bsxslot    = source.bsxslot;
-  superfx    = source.superfx;
-  sa1        = source.sa1;
-  srtc       = source.srtc;
-  sdd1       = source.sdd1;
-  spc7110    = source.spc7110;
-  spc7110rtc = source.spc7110rtc;
-  cx4        = source.cx4;
-  dsp1       = source.dsp1;
-  dsp2       = source.dsp2;
-  dsp3       = source.dsp3;
-  dsp4       = source.dsp4;
-  obc1       = source.obc1;
-  st010      = source.st010;
-  st011      = source.st011;
-  st018      = source.st018;
-
-  return *this;
+Cartridge::cartinfo_t::cartinfo_t() {
+  reset();
+}
+
+//=======
+//utility
+//=======
+
+//ensure file path is absolute (eg resolve relative paths)
+string Cartridge::filepath(const char *filename, const char *pathname) {
+  //if no pathname, return filename as-is
+  string file(filename);
+  file.replace("\\", "/");
+
+  string path = (!pathname || !*pathname) ? (const char*)snes.config.path.current : pathname;
+  //ensure path ends with trailing '/'
+  path.replace("\\", "/");
+  if(!strend(path, "/")) path.append("/");
+
+  //replace relative path with absolute path
+  if(strbegin(path, "./")) {
+    ltrim(path, "./");
+    path = string() << snes.config.path.base << path;
+  }
+
+  //remove folder part of filename
+  lstring part;
+  part.split("/", file);
+  return path << part[part.size() - 1];
+}
+
+//remove directory information and file extension ("/foo/bar.ext" -> "bar")
+string Cartridge::basename(const char *filename) {
+  string name(filename);
+
+  //remove extension
+  for(signed i = strlen(name) - 1; i >= 0; i--) {
+    if(name[i] == '.') {
+      name[i] = 0;
+      break;
+    }
+  }
+
+  //remove directory information
+  for(signed i = strlen(name) - 1; i >= 0; i--) {
+    if(name[i] == '/' || name[i] == '\\') {
+      i++;
+      char *output = name();
+      while(true) {
+        *output++ = name[i];
+        if(!name[i]) break;
+        i++;
+      }
+      break;
+    }
+  }
+
+  return name;
+}
+
+//remove filename and return path only ("/foo/bar.ext" -> "/foo/bar/")
+string Cartridge::basepath(const char *filename) {
+  string path(filename);
+  path.replace("\\", "/");
+
+  //remove filename
+  for(signed i = strlen(path) - 1; i >= 0; i--) {
+    if(path[i] == '/') {
+      path[i] = 0;
+      break;
+    }
+  }
+
+  if(!strend(path, "/")) path.append("/");
+  return path;
 }

src/cart/cart.hpp

@@ -1,39 +1,25 @@
-class Cartridge {
+class Cartridge : public property {
 public:
-  enum CartridgeMode {
+  enum Mode {
     ModeNormal,
-    ModeBSC,
-    ModeBSX,
+    ModeBsxSlotted,
+    ModeBsx,
     ModeSufamiTurbo,
   };
 
-  enum CartridgeType {
+  enum Type {
     TypeNormal,
-    TypeBSC,
-    TypeBSXBIOS,
-    TypeBSX,
-    TypeSufamiTurboBIOS,
+    TypeBsxSlotted,
+    TypeBsxBios,
+    TypeBsx,
+    TypeSufamiTurboBios,
     TypeSufamiTurbo,
     TypeUnknown,
   };
 
-  enum HeaderField {
-    CartName    = 0x00,
-    Mapper      = 0x15,
-    RomType     = 0x16,
-    RomSize     = 0x17,
-    RamSize     = 0x18,
-    CartRegion  = 0x19,
-    Company     = 0x1a,
-    Version     = 0x1b,
-    Complement  = 0x1c,  //inverse checksum
-    Checksum    = 0x1e,
-    ResetVector = 0x3c,
-  };
-
-  enum Region {
-    NTSC,
-    PAL,
+  enum Region {
+    NTSC,
+    PAL,
   };
 
   enum MemoryMapper {
@@ -55,142 +41,131 @@ public:
     DSP1HiROM,
   };
 
-  const char* name();
-  CartridgeMode mode();
-  MemoryMapper mapper();
-  Region region();
+  //properties can be read via operator(), eg "if(cartridge.loaded() == true)";
+  //warning: if loaded() == false, no other property is considered valid!
 
-  struct {
-    bool loaded;
-    char fn[PATH_MAX];
-    uint8 *rom, *ram, *rtc;
-    uint rom_size, ram_size, rtc_size;
-  } cart;
+  property_t<bool>   loaded;            //is a base cartridge inserted?
+  property_t<bool>   bsx_flash_loaded;  //is a BS-X flash cart connected?
+  property_t<bool>   patched;           //has a UPS patch been applied?
+  property_t<string> name;              //display name (filename sans path and extension)
 
-  struct {
-    char fn[PATH_MAX];
-    uint8 *ram;
-    uint ram_size;
-  } bs;
+  property_t<Mode>             mode;
+  property_t<Region>           region;
+  property_t<MemoryMapper>     mapper;
+  property_t<DSP1MemoryMapper> dsp1_mapper;
 
-  struct {
-    char fn[PATH_MAX];
-    uint8 *rom, *ram;
-    uint rom_size, ram_size;
-  } stA, stB;
+  property_t<bool> has_bsx_slot;
+  property_t<bool> has_superfx;
+  property_t<bool> has_sa1;
+  property_t<bool> has_srtc;
+  property_t<bool> has_sdd1;
+  property_t<bool> has_spc7110, has_spc7110rtc;
+  property_t<bool> has_cx4;
+  property_t<bool> has_dsp1, has_dsp2, has_dsp3, has_dsp4;
+  property_t<bool> has_obc1;
+  property_t<bool> has_st010, has_st011, has_st018;
 
-  struct cartinfo_t {
-    CartridgeType type;
-    MemoryMapper mapper;
-    DSP1MemoryMapper dsp1_mapper;
-    Region region;
+  //main interface
+  bool load_normal      (const char *base);
+  bool load_bsx_slotted (const char *base, const char *slot  = "");
+  bool load_bsx         (const char *base, const char *slot  = "");
+  bool load_sufami_turbo(const char *base, const char *slotA = "", const char *slotB = "");
+  void unload();
 
-    unsigned rom_size;
-    unsigned ram_size;
-
-    bool bsxslot;
-    bool superfx;
-    bool sa1;
-    bool srtc;
-    bool sdd1;
-    bool spc7110;
-    bool spc7110rtc;
-    bool cx4;
-    bool dsp1;
-    bool dsp2;
-    bool dsp3;
-    bool dsp4;
-    bool obc1;
-    bool st010;
-    bool st011;
-    bool st018;
-
-    void reset();
-  };
-
-  struct info_t {
-    char filename[PATH_MAX * 4];
-    bool patched;
-
-    CartridgeMode mode;
-    MemoryMapper mapper;
-    DSP1MemoryMapper dsp1_mapper;
-    Region region;
-
-    bool bsxcart;   //is BS-X cart inserted?
-    bool bsxflash;  //is BS-X flash cart inserted into BS-X cart?
-
-    bool bsxslot;
-    bool superfx;
-    bool sa1;
-    bool srtc;
-    bool sdd1;
-    bool spc7110;
-    bool spc7110rtc;
-    bool cx4;
-    bool dsp1;
-    bool dsp2;
-    bool dsp3;
-    bool dsp4;
-    bool obc1;
-    bool st010;
-    bool st011;
-    bool st018;
-
-    info_t& operator=(const cartinfo_t&);
-  } info;
-
-  struct {
-    char fn[PATH_MAX];
-    uint8_t *data;
-    unsigned size;
-  } image;
-  bool load_image(const char*);
-  bool inspect_image(cartinfo_t &cartinfo, const char *filename);
-  bool load_ram(const char *filename, uint8_t *&data, unsigned size, uint8_t init);
-
-  void load_cart_normal(const char*);
-  void load_cart_bsc(const char*, const char*);
-  void load_cart_bsx(const char*, const char*);
-  void load_cart_st(const char*, const char*, const char*);
-
-  void unload_cart_normal();
-  void unload_cart_bsx();
-  void unload_cart_bsc();
-  void unload_cart_st();
-
-  bool loaded();
-  void load_begin(CartridgeMode);
-  void load_end();
-  bool unload();
-
-  void read_header(cartinfo_t &info, const uint8_t *data, unsigned size);
-  unsigned find_header(const uint8_t *data, unsigned size);
-  unsigned score_header(const uint8_t *data, unsigned size, unsigned addr);
-
-  enum CompressionMode {
-    CompressionNone,    //always load without compression
-    CompressionInspect, //use file header inspection
-    CompressionAuto,    //use file extension or file header inspection (configured by user)
-  };
-  bool load_file(const char *fn, uint8 *&data, uint &size, CompressionMode compression = CompressionNone);
-  bool save_file(const char *fn, uint8 *data, uint size);
-  bool apply_patch(const uint8_t *pdata, unsigned psize, uint8_t *&data, unsigned &size);
-  char* modify_extension(char *filename, const char *extension);
-  char* get_base_filename(char *filename);
-  char* get_path_filename(char *filename, const char *path, const char *source, const char *extension);
-  char* get_patch_filename(const char *source, const char *extension);
-  char* get_save_filename(const char *source, const char *extension);
-  char* get_cheat_filename(const char *source, const char *extension);
+  //utility functions
+  static string filepath(const char *filename, const char *pathname);  //"./bar.ext" -> "/foo/bar.ext"
+  static string basename(const char *filename);                        //"/foo/bar.ext" -> "bar"
+  static string basepath(const char *filename);                        //"/foo/bar.ext" -> "/foo/bar/"
+  //this function will load 'filename', decompress it if needed, and determine what type of
+  //image file 'filename' refers to (eg normal cart, BS-X flash cart, Sufami Turbo cart, etc.)
+  //warning: this operation is very expensive, use sparingly!
+  Type detect_image_type(const char *filename) const;
 
   Cartridge();
   ~Cartridge();
 
-private:
-  char patchfn[PATH_MAX];
-  char savefn[PATH_MAX];
-  char rtcfn[PATH_MAX];
-  char cheatfn[PATH_MAX];
+private:
+  void load_begin(Mode);
+  void load_end();
+  void unload_normal();
+  void unload_bsx_slotted();
+  void unload_bsx();
+  void unload_sufami_turbo();
+
+  struct cartinfo_t {
+    Type type;
+    Region region;
+    MemoryMapper mapper;
+    DSP1MemoryMapper dsp1_mapper;
+    unsigned rom_size, ram_size;
+
+    bool bsx_slot;
+    bool superfx;
+    bool sa1;
+    bool srtc;
+    bool sdd1;
+    bool spc7110, spc7110rtc;
+    bool cx4;
+    bool dsp1, dsp2, dsp3, dsp4;
+    bool obc1;
+    bool st010, st011, st018;
+
+    void reset();
+    cartinfo_t();
+  };
+
+  enum HeaderField {
+    CartName    = 0x00,
+    Mapper      = 0x15,
+    RomType     = 0x16,
+    RomSize     = 0x17,
+    RamSize     = 0x18,
+    CartRegion  = 0x19,
+    Company     = 0x1a,
+    Version     = 0x1b,
+    Complement  = 0x1c,  //inverse checksum
+    Checksum    = 0x1e,
+    ResetVector = 0x3c,
+  };
+
+  void read_header(cartinfo_t &info, const uint8_t *data, unsigned size) const;
+  unsigned find_header(const uint8_t *data, unsigned size) const;
+  unsigned score_header(const uint8_t *data, unsigned size, unsigned addr) const;
+  void set_cartinfo(const cartinfo_t&);
+
+  bool load_image(const char *filename, uint8_t *&data, unsigned &size, bool &patched) const;
+  bool load_ram  (const char *filename, uint8_t *&data, unsigned  size, uint8_t init_value) const;
+
+  enum CompressionMode {
+    CompressionNone,     //always load without compression
+    CompressionInspect,  //use file header inspection
+    CompressionAuto,     //use file extension or file header inspection (configured by user)
+  };
+
+  bool load_file(const char *fn, uint8 *&data, unsigned &size, CompressionMode compression = CompressionNone) const;
+  bool save_file(const char *fn, uint8 *data, unsigned size) const;
+  bool apply_patch(const uint8_t *pdata, unsigned psize, uint8_t *&data, unsigned &size) const;
+
+  string modify_extension(const char *filename, const char *extension) const;
+  string get_filename(const char *source, const char *extension, const char *path) const;
+
+  struct {
+    string filename;
+    uint8_t *rom, *ram, *rtc;
+    unsigned rom_size, ram_size, rtc_size;
+  } cart;
+
+  struct {
+    string filename;
+    uint8_t *ram;
+    unsigned ram_size;
+  } bs;
+
+  struct {
+    string filename;
+    uint8_t *rom, *ram;
+    unsigned rom_size, ram_size;
+  } stA, stB;
 };
 
 namespace memory {

src/cart/cart_bsc.cpp

@@ -1,44 +0,0 @@
-#ifdef CART_CPP
-
-void Cartridge::load_cart_bsc(const char *base, const char *slot) {
-  uint8_t *data;
-  unsigned size;
-  strcpy(cart.fn, base);
-  strcpy(bs.fn, slot);
-
-  load_begin(ModeBSC);
-  if(load_image(base) == false) return;
-
-  cartinfo_t cartinfo;
-  read_header(cartinfo, cart.rom = image.data, cart.rom_size = image.size);
-  info = cartinfo;
-
-  if(load_image(slot) == true) {
-    info.bsxflash = true;
-    bs.ram = image.data;
-    bs.ram_size = image.size;
-  }
-
-  if(cartinfo.ram_size > 0) {
-    load_ram(get_save_filename(base, "srm"), cart.ram, cart.ram_size = cartinfo.ram_size, 0xff);
-  }
-
-  load_end();
-
-  //set base filename
-  strcpy(info.filename, base);
-  get_base_filename(info.filename);
-  if(*slot) {
-    char filenameBS[PATH_MAX];
-    strcpy(filenameBS, slot);
-    get_base_filename(filenameBS);
-    strcat(info.filename, " + ");
-    strcat(info.filename, filenameBS);
-  }
-}
-
-void Cartridge::unload_cart_bsc() {
-  if(cart.ram) save_file(get_save_filename(cart.fn, "srm"), cart.ram, cart.ram_size);
-}
-
-#endif //ifdef CART_CPP

src/cart/cart_bsx.cpp

@@ -1,49 +0,0 @@
-#ifdef CART_CPP
-
-void Cartridge::load_cart_bsx(const char *base, const char *slot) {
-  uint8_t *data;
-  unsigned size;
-  strcpy(cart.fn, base);
-  strcpy(bs.fn, slot);
-
-  load_begin(ModeBSX);
-  if(load_image(base) == false) return;
-  info.bsxcart = true;
-
-  cartinfo_t cartinfo;
-  read_header(cartinfo, cart.rom = image.data, cart.rom_size = image.size);
-  info = cartinfo;
-  cart.ram = 0;
-  cart.ram_size = 0;
-
-  memset(bsxcart.sram.handle (), 0x00, bsxcart.sram.size ());
-  memset(bsxcart.psram.handle(), 0x00, bsxcart.psram.size());
-
-  if(load_file(get_save_filename(cart.fn, "srm"), data, size, CompressionNone) == true) {
-    memcpy(bsxcart.sram.handle (), data, min(bsxcart.sram.size (), size));
-    delete[] data;
-  }
-
-  if(load_file(get_save_filename(cart.fn, "psr"), data, size, CompressionNone) == true) {
-    memcpy(bsxcart.psram.handle(), data, min(bsxcart.psram.size(), size));
-    delete[] data;
-  }
-
-  if(load_image(slot)) {
-    info.bsxflash = true;
-    bs.ram = image.data;
-    bs.ram_size = image.size;
-  }
-
-  load_end();
-
-  strcpy(info.filename, !*slot ? base : slot);
-  get_base_filename(info.filename);
-}
-
-void Cartridge::unload_cart_bsx() {
-  save_file(get_save_filename(cart.fn, "srm"), bsxcart.sram.handle (), bsxcart.sram.size ());
-  save_file(get_save_filename(cart.fn, "psr"), bsxcart.psram.handle(), bsxcart.psram.size());
-}
-
-#endif //ifdef CART_CPP

src/cart/cart_file.cpp

@@ -11,71 +11,28 @@
   #include "../reader/jmareader.hpp"
 #endif
 
-char* Cartridge::modify_extension(char *filename, const char *extension) {
+string Cartridge::modify_extension(const char *filename_, const char *extension) const {
+  string filename = filename_;
   int i;
   for(i = strlen(filename); i >= 0; i--) {
-    if(filename[i] == '.') break;
-    if(filename[i] == '/') break;
+    if(filename[i] == '.')  break;
+    if(filename[i] == '/')  break;
     if(filename[i] == '\\') break;
   }
   if(i > 0 && filename[i] == '.') filename[i] = 0;
-  strcat(filename, ".");
-  strcat(filename, extension);
-  return filename;
+  return filename << "." << extension;
 }
 
-//remove directory information and file extension ("/foo/bar.ext" -> "bar")
-char* Cartridge::get_base_filename(char *filename) {
-  //remove extension
-  for(int i = strlen(filename) - 1; i >= 0; i--) {
-    if(filename[i] == '.') {
-      filename[i] = 0;
-      break;
-    }
-  }
-
-  //remove directory information
-  for(int i = strlen(filename) - 1; i >= 0; i--) {
-    if(filename[i] == '/' || filename[i] == '\\') {
-      i++;
-      char *output = filename;
-      while(true) {
-        *output++ = filename[i];
-        if(!filename[i]) break;
-        i++;
-      }
-      break;
-    }
-  }
-
-  return filename;
+string Cartridge::get_filename(const char *source, const char *extension, const char *path) const {
+  return filepath(modify_extension(source, extension), path);
 }
 
-char* Cartridge::get_path_filename(char *filename, const char *path, const char *source, const char *extension) {
-  strcpy(filename, source);
-  modify_extension(filename, extension);
-  strcpy(filename, config::filepath(filename, path));
-  return filename;
-}
-
-char* Cartridge::get_patch_filename(const char *source, const char *extension) {
-  return get_path_filename(patchfn, config::path.patch, source, extension);
-}
-
-char* Cartridge::get_save_filename(const char *source, const char *extension) {
-  return get_path_filename(savefn, config::path.save, source, extension);
-}
-
-char* Cartridge::get_cheat_filename(const char *source, const char *extension) {
-  return get_path_filename(cheatfn, config::path.cheat, source, extension);
-}
-
-bool Cartridge::load_file(const char *fn, uint8 *&data, uint &size, CompressionMode compression) {
+bool Cartridge::load_file(const char *fn, uint8 *&data, unsigned &size, CompressionMode compression) const {
   if(file::exists(fn) == false) return false;
 
   Reader::Type filetype = Reader::Normal;
   if(compression == CompressionInspect) filetype = Reader::detect(fn, true);
-  if(compression == CompressionAuto) filetype = Reader::detect(fn, config::file.autodetect_type);
+  if(compression == CompressionAuto) filetype = Reader::detect(fn, snes.config.file.autodetect_type);
 
   switch(filetype) { default:
     case Reader::Normal: {
@@ -117,7 +74,7 @@ bool Cartridge::load_file(const char *fn, uint8 *&data, uint &size, CompressionM
   return true;
 }
 
-bool Cartridge::apply_patch(const uint8_t *pdata, const unsigned psize, uint8_t *&data, unsigned &size) {
+bool Cartridge::apply_patch(const uint8_t *pdata, const unsigned psize, uint8_t *&data, unsigned &size) const {
   uint8_t *outdata = 0;
   unsigned outsize;
   ups patcher;
@@ -125,8 +82,8 @@ bool Cartridge::apply_patch(const uint8_t *pdata, const unsigned psize, uint8_t
 
   bool apply = false;
   if(result == ups::ok) apply = true;
-  if(config::file.bypass_patch_crc32 == true) {
-    if(result == ups::input_crc32_invalid) apply = true;
+  if(snes.config.file.bypass_patch_crc32 == true) {
+    if(result == ups::input_crc32_invalid)  apply = true;
     if(result == ups::output_crc32_invalid) apply = true;
   }
 
@@ -141,7 +98,7 @@ bool Cartridge::apply_patch(const uint8_t *pdata, const unsigned psize, uint8_t
   return apply;
 }
 
-bool Cartridge::save_file(const char *fn, uint8 *data, uint size) {
+bool Cartridge::save_file(const char *fn, uint8 *data, unsigned size) const {
   file fp;
   if(!fp.open(fn, file::mode_write)) return false;
   fp.write(data, size);
@@ -149,4 +106,4 @@ bool Cartridge::save_file(const char *fn, uint8 *data, uint size) {
   return true;
 }
 
-#endif //ifdef CART_CPP
+#endif

src/cart/cart_header.cpp

@@ -1,16 +1,19 @@
 #ifdef CART_CPP
 
-void Cartridge::read_header(cartinfo_t &info, const uint8_t *data, unsigned size) {
+void Cartridge::read_header(cartinfo_t &info, const uint8_t *data, unsigned size) const {
   info.reset();
   unsigned index = find_header(data, size);
 
+  //=======================
   //detect BS-X flash carts
+  //=======================
+
   if(data[index + 0x13] == 0x00 || data[index + 0x13] == 0xff) {
     if(data[index + 0x14] == 0x00) {
       const uint8_t n15 = data[index + 0x15];
       if(n15 == 0x00 || n15 == 0x80 || n15 == 0x84 || n15 == 0x9c || n15 == 0xbc || n15 == 0xfc) {
         if(data[index + 0x1a] == 0x33 || data[index + 0x1a] == 0xff) {
-          info.type = TypeBSX;
+          info.type = TypeBsx;
           info.mapper = BSXROM;
           info.region = NTSC;  //BS-X only released in Japan
           return;
@@ -19,24 +22,30 @@ void Cartridge::read_header(cartinfo_t &info, const uint8_t *data, unsigned size
     }
   }
 
+  //=========================
   //detect Sufami Turbo carts
+  //=========================
+
   if(!memcmp(data, "BANDAI SFC-ADX", 14)) {
     if(!memcmp(data + 16, "SFC-ADX BACKUP", 14)) {
-      info.type = TypeSufamiTurboBIOS;
+      info.type = TypeSufamiTurboBios;
     } else {
       info.type = TypeSufamiTurbo;
     }
     info.mapper = STROM;
     info.region = NTSC;  //Sufami Turbo only released in Japan
-    return;
+    return;              //RAM size handled internally by load_cart_st();
   }
 
-  //standard cart
-  uint8 mapper   = data[index + Mapper];
-  uint8 rom_type = data[index + RomType];
-  uint8 rom_size = data[index + RomSize];
-  uint8 company  = data[index + Company];
-  uint8 region   = data[index + CartRegion] & 0x7f;
+  //=====================
+  //detect standard carts
+  //=====================
+
+  const uint8 mapper   = data[index + Mapper];
+  const uint8 rom_type = data[index + RomType];
+  const uint8 rom_size = data[index + RomSize];
+  const uint8 company  = data[index + Company];
+  const uint8 region   = data[index + CartRegion] & 0x7f;
 
   //detect presence of BS-X flash cartridge connector (reads extended header information)
   if(data[index - 14] == 'Z') {
@@ -44,36 +53,38 @@ void Cartridge::read_header(cartinfo_t &info, const uint8_t *data, unsigned size
       uint8 n13 = data[index - 13];
       if((n13 >= 'A' && n13 <= 'Z') || (n13 >= '0' && n13 <= '9')) {
         if(company == 0x33 || (data[index - 10] == 0x00 && data[index - 4] == 0x00)) {
-          info.bsxslot = true;
+          info.bsx_slot = true;
         }
       }
     }
   }
 
-  if(info.bsxslot == true) {
+  if(info.bsx_slot == true) {
     if(!memcmp(data + index, "Satellaview BS-X     ", 21)) {
       //BS-X base cart
-      info.type = TypeBSXBIOS;
+      info.type = TypeBsxBios;
       info.mapper = BSXROM;
+      info.region = NTSC;  //BS-X only released in Japan
+      return;              //RAM size handled internally by load_cart_bsx() -> BSXCart class
     } else {
-      info.type = TypeBSC;
+      info.type = TypeBsxSlotted;
       info.mapper = (index == 0x7fc0 ? BSCLoROM : BSCHiROM);
     }
-    return;
-  }
+  } else {
+    //standard cart
+    info.type = TypeNormal;
 
-  info.type = TypeNormal;
-
-  if(index == 0x7fc0 && size >= 0x401000) {
-    info.mapper = ExLoROM;
-  } else if(index == 0x7fc0 && mapper == 0x32) {
-    info.mapper = ExLoROM;
-  } else if(index == 0x7fc0) {
-    info.mapper = LoROM;
-  } else if(index == 0xffc0) {
-    info.mapper = HiROM;
-  } else { //index == 0x40ffc0
-    info.mapper = ExHiROM;
+    if(index == 0x7fc0 && size >= 0x401000) {
+      info.mapper = ExLoROM;
+    } else if(index == 0x7fc0 && mapper == 0x32) {
+      info.mapper = ExLoROM;
+    } else if(index == 0x7fc0) {
+      info.mapper = LoROM;
+    } else if(index == 0xffc0) {
+      info.mapper = HiROM;
+    } else {  //index == 0x40ffc0
+      info.mapper = ExHiROM;
+    }
   }
 
   if(mapper == 0x20 && (rom_type == 0x13 || rom_type == 0x14 || rom_type == 0x15 || rom_type == 0x1a)) {
@@ -162,7 +173,7 @@ void Cartridge::read_header(cartinfo_t &info, const uint8_t *data, unsigned size
   info.region = (region <= 1 || region >= 13) ? NTSC : PAL;
 }
 
-unsigned Cartridge::find_header(const uint8_t *data, unsigned size) {
+unsigned Cartridge::find_header(const uint8_t *data, unsigned size) const {
   unsigned score_lo = score_header(data, size, 0x007fc0);
   unsigned score_hi = score_header(data, size, 0x00ffc0);
   unsigned score_ex = score_header(data, size, 0x40ffc0);
@@ -177,7 +188,7 @@ unsigned Cartridge::find_header(const uint8_t *data, unsigned size) {
   }
 }
 
-unsigned Cartridge::score_header(const uint8_t *data, unsigned size, unsigned addr) {
+unsigned Cartridge::score_header(const uint8_t *data, unsigned size, unsigned addr) const {
   if(size < addr + 64) return 0;  //image too small to contain header at this location?
   int score = 0;
 
@@ -186,7 +197,7 @@ unsigned Cartridge::score_header(const uint8_t *data, unsigned size, unsigned ad
   uint16 complement  = data[addr + Complement ] | (data[addr + Complement  + 1] << 8);
 
   uint8 resetop = data[(addr & ~0x7fff) | (resetvector & 0x7fff)];  //first opcode executed upon reset
-  uint8 mapper  = data[addr + Mapper] & ~0x10;  //mask off irrelevent FastROM-capable bit
+  uint8 mapper  = data[addr + Mapper] & ~0x10;                      //mask off irrelevent FastROM-capable bit
 
   //$00:[000-7fff] contains uninitialized RAM and MMIO.
   //reset vector must point to ROM at $00:[8000-ffff] to be considered valid.
@@ -248,7 +259,7 @@ unsigned Cartridge::score_header(const uint8_t *data, unsigned size, unsigned ad
   if(addr == 0x007fc0 && mapper == 0x22) score += 2;  //0x22 is usually ExLoROM
   if(addr == 0x40ffc0 && mapper == 0x25) score += 2;  //0x25 is usually ExHiROM
 
-  if(data[addr + Company] == 0x33) score += 2;  //0x33 indicates extended header
+  if(data[addr + Company] == 0x33) score += 2;        //0x33 indicates extended header
   if(data[addr + RomType] < 0x08) score++;
   if(data[addr + RomSize] < 0x10) score++;
   if(data[addr + RamSize] < 0x08) score++;
@@ -258,4 +269,4 @@ unsigned Cartridge::score_header(const uint8_t *data, unsigned size, unsigned ad
   return score;
 }
 
-#endif //ifdef CART_CPP
+#endif

src/cart/cart_load.cpp

@@ -1,50 +0,0 @@
-#ifdef CART_CPP
-
-bool Cartridge::load_image(const char *filename) {
-  if(!filename || !*filename) return false;
-
-  uint8_t *data;
-  unsigned size;
-  if(!load_file(filename, data, size, CompressionAuto)) return false;
-
-  if((size & 0x7fff) != 512) {
-    image.data = data;
-    image.size = size;
-  } else {
-    //remove 512-byte header
-    image.data = new uint8_t[image.size = size - 512];
-    memcpy(image.data, data + 512, image.size);
-  }
-
-  if(load_file(get_patch_filename(filename, "ups"), data, size, CompressionInspect) == true) {
-    apply_patch(data, size, image.data, image.size);
-    delete[] data;
-    info.patched = true;
-  }
-
-  return true;
-}
-
-bool Cartridge::inspect_image(cartinfo_t &cartinfo, const char *filename) {
-  cartinfo.reset();
-  if(!load_image(filename)) return false;
-
-  read_header(cartinfo, image.data, image.size);
-  delete[] image.data;
-  return true;
-}
-
-bool Cartridge::load_ram(const char *filename, uint8_t *&data, unsigned size, uint8_t init) {
-  data = new uint8_t[size];
-  memset(data, init, size);
-
-  uint8_t *savedata;
-  unsigned savesize;
-  if(load_file(filename, savedata, savesize, CompressionNone) == false) return false;
-
-  memcpy(data, savedata, min(size, savesize));
-  delete[] savedata;
-  return true;
-}
-
-#endif //ifdef CART_CPP

src/cart/cart_loader.cpp

@@ -0,0 +1,244 @@
+#ifdef CART_CPP
+
+//================
+//Normal cartridge
+//================
+
+bool Cartridge::load_normal(const char *base) {
+  uint8_t *data;
+  unsigned size;
+  bool patch_applied;
+  cart.filename = base;
+
+  load_begin(ModeNormal);
+  if(load_image(base, data, size, patch_applied) == false) return false;
+
+  snes.config.path.current = basepath(cart.filename);
+  if(patch_applied) set(patched, true);
+
+  cartinfo_t cartinfo;
+  read_header(cartinfo, cart.rom = data, cart.rom_size = size);
+  set_cartinfo(cartinfo);
+
+  if(cartinfo.ram_size > 0) {
+    load_ram(get_filename(base, "srm", snes.config.path.save), cart.ram, cart.ram_size = cartinfo.ram_size, 0xff);
+  }
+
+  if(cartinfo.srtc || cartinfo.spc7110rtc) {
+    load_ram(get_filename(base, "rtc", snes.config.path.save), cart.rtc, cart.rtc_size = 20, 0x00);
+  }
+
+  load_end();
+  set(name, basename(base));
+  return true;
+}
+
+void Cartridge::unload_normal() {
+  if(cart.ram) save_file(get_filename(cart.filename, "srm", snes.config.path.save), cart.ram, cart.ram_size);
+  if(cart.rtc) save_file(get_filename(cart.filename, "rtc", snes.config.path.save), cart.rtc, cart.rtc_size);
+}
+
+//======================
+//BS-X slotted cartridge
+//======================
+
+bool Cartridge::load_bsx_slotted(const char *base, const char *slot) {
+  uint8_t *data;
+  unsigned size;
+  bool patch_applied;
+  cart.filename = base;
+  bs.filename = slot;
+
+  load_begin(ModeBsxSlotted);
+  if(load_image(base, data, size, patch_applied) == false) return false;
+
+  snes.config.path.current = basepath(cart.filename);
+  if(patch_applied) set(patched, true);
+
+  cartinfo_t cartinfo;
+  read_header(cartinfo, cart.rom = data, cart.rom_size = size);
+  set_cartinfo(cartinfo);
+
+  if(load_image(slot, data, size, patch_applied) == true) {
+    set(bsx_flash_loaded, true);
+    if(patch_applied) set(patched, true);
+    bs.ram = data;
+    bs.ram_size = size;
+  }
+
+  if(cartinfo.ram_size > 0) {
+    load_ram(get_filename(base, "srm", snes.config.path.save), cart.ram, cart.ram_size = cartinfo.ram_size, 0xff);
+  }
+
+  load_end();
+  string filename = basename(base);
+  if(*slot) filename << " + " << basename(slot);
+  set(name, filename);
+  return true;
+}
+
+void Cartridge::unload_bsx_slotted() {
+  if(cart.ram) save_file(get_filename(cart.filename, "srm", snes.config.path.save), cart.ram, cart.ram_size);
+}
+
+//====================
+//BS-X flash cartridge
+//====================
+
+bool Cartridge::load_bsx(const char *base, const char *slot) {
+  uint8_t *data;
+  unsigned size;
+  bool patch_applied;
+  cart.filename = base;
+  bs.filename = slot;
+
+  load_begin(ModeBsx);
+  if(load_image(base, data, size, patch_applied) == false) return false;
+
+  snes.config.path.current = basepath(cart.filename);
+  if(patch_applied) set(patched, true);
+
+  cartinfo_t cartinfo;
+  read_header(cartinfo, cart.rom = data, cart.rom_size = size);
+  set_cartinfo(cartinfo);
+
+  cart.ram = 0;
+  cart.ram_size = 0;
+
+  memset(bsxcart.sram.handle (), 0x00, bsxcart.sram.size ());
+  memset(bsxcart.psram.handle(), 0x00, bsxcart.psram.size());
+
+  if(load_file(get_filename(base, "srm", snes.config.path.save), data, size, CompressionNone) == true) {
+    memcpy(bsxcart.sram.handle (), data, min(bsxcart.sram.size (), size));
+    delete[] data;
+  }
+
+  if(load_file(get_filename(base, "psr", snes.config.path.save), data, size, CompressionNone) == true) {
+    memcpy(bsxcart.psram.handle(), data, min(bsxcart.psram.size(), size));
+    delete[] data;
+  }
+
+  if(load_image(slot, data, size, patch_applied)) {
+    set(bsx_flash_loaded, true);
+    if(patch_applied) set(patched, true);
+    bs.ram = data;
+    bs.ram_size = size;
+  }
+
+  load_end();
+  set(name, !*slot ? basename(base) : basename(slot));
+  return true;
+}
+
+void Cartridge::unload_bsx() {
+  save_file(get_filename(cart.filename, "srm", snes.config.path.save), bsxcart.sram.handle (), bsxcart.sram.size ());
+  save_file(get_filename(cart.filename, "psr", snes.config.path.save), bsxcart.psram.handle(), bsxcart.psram.size());
+}
+
+//============================
+//Sufami Turbo flash cartridge
+//============================
+
+bool Cartridge::load_sufami_turbo(const char *base, const char *slotA, const char *slotB) {
+  uint8_t *data;
+  unsigned size;
+  bool patch_applied;
+  cart.filename = base;
+  stA.filename = slotA;
+  stB.filename = slotB;
+
+  load_begin(ModeSufamiTurbo);
+  if(load_image(base, data, size, patch_applied) == false) return false;
+
+  snes.config.path.current = basepath(cart.filename);
+  if(patch_applied) set(patched, true);
+
+  cartinfo_t cartinfo;
+  read_header(cartinfo, cart.rom = data, cart.rom_size = size);
+  set_cartinfo(cartinfo);
+
+  if(load_image(slotA, data, size, patch_applied)) {
+    if(patch_applied) set(patched, true);
+    stA.rom = new(zeromemory) uint8_t[stA.rom_size = 0x100000];
+    memcpy(stA.rom, data, min(size, stA.rom_size));
+    delete[] data;
+
+    load_ram(get_filename(slotA, "srm", snes.config.path.save), stA.ram, stA.ram_size = 0x020000, 0xff);
+  }
+
+  if(load_image(slotB, data, size, patch_applied)) {
+    if(patch_applied) set(patched, true);
+    stB.rom = new(zeromemory) uint8_t[stB.rom_size = 0x100000];
+    memcpy(stB.rom, data, min(size, stB.rom_size));
+    delete[] data;
+
+    load_ram(get_filename(slotB, "srm", snes.config.path.save), stB.ram, stB.ram_size = 0x020000, 0xff);
+  }
+
+  load_end();
+  string filename;
+       if(!*slotA && !*slotB) filename << basename(base);
+  else if( *slotA && !*slotB) filename << basename(slotA);
+  else if(!*slotA &&  *slotB) filename << basename(slotB);
+  else filename << basename(slotA) << " + " << basename(slotB);
+  set(name, filename);
+  return true;
+}
+
+void Cartridge::unload_sufami_turbo() {
+  if(stA.ram) save_file(get_filename(stA.filename, "srm", snes.config.path.save), stA.ram, stA.ram_size);
+  if(stB.ram) save_file(get_filename(stB.filename, "srm", snes.config.path.save), stB.ram, stB.ram_size);
+}
+
+//=================
+//utility functions
+//=================
+
+Cartridge::Type Cartridge::detect_image_type(const char *filename) const {
+  uint8_t *data;
+  unsigned size;
+  bool patch_applied;
+  if(!load_image(filename, data, size, patch_applied)) return TypeUnknown;
+
+  cartinfo_t info;
+  read_header(info, data, size);
+  delete[] data;
+  return info.type;
+}
+
+bool Cartridge::load_image(const char *filename, uint8_t *&data, unsigned &size, bool &patched) const {
+  if(!filename || !*filename) return false;
+  if(!load_file(filename, data, size, CompressionAuto)) return false;
+
+  if((size & 0x7fff) == 512) {
+    //remove 512-byte header
+    memmove(data, data + 512, size -= 512);
+  }
+
+  uint8_t *pdata;
+  unsigned psize;
+  if(load_file(get_filename(filename, "ups", snes.config.path.patch), pdata, psize, CompressionInspect) == true) {
+    apply_patch(pdata, psize, data, size);
+    delete[] pdata;
+    patched = true;
+  } else {
+    patched = false;
+  }
+
+  return true;
+}
+
+bool Cartridge::load_ram(const char *filename, uint8_t *&data, unsigned size, uint8_t init) const {
+  data = new uint8_t[size];
+  memset(data, init, size);
+
+  uint8_t *savedata;
+  unsigned savesize;
+  if(load_file(filename, savedata, savesize, CompressionNone) == false) return false;
+
+  memcpy(data, savedata, min(size, savesize));
+  delete[] savedata;
+  return true;
+}
+
+#endif

src/cart/cart_normal.cpp

@@ -1,35 +0,0 @@
-#ifdef CART_CPP
-
-void Cartridge::load_cart_normal(const char *base) {
-  uint8_t *data;
-  unsigned size;
-  strcpy(cart.fn, base);
-
-  load_begin(ModeNormal);
-  if(load_image(base) == false) return;
-
-  cartinfo_t cartinfo;
-  read_header(cartinfo, cart.rom = image.data, cart.rom_size = image.size);
-  info = cartinfo;
-
-  if(cartinfo.ram_size > 0) {
-    load_ram(get_save_filename(base, "srm"), cart.ram, cart.ram_size = cartinfo.ram_size, 0xff);
-  }
-
-  if(cartinfo.srtc || cartinfo.spc7110rtc) {
-    load_ram(get_save_filename(base, "rtc"), cart.rtc, cart.rtc_size = 20, 0x00);
-  }
-
-  load_end();
-
-  //set base filename
-  strcpy(info.filename, base);
-  get_base_filename(info.filename);
-}
-
-void Cartridge::unload_cart_normal() {
-  if(cart.ram) save_file(get_save_filename(cart.fn, "srm"), cart.ram, cart.ram_size);
-  if(cart.rtc) save_file(get_save_filename(cart.fn, "rtc"), cart.rtc, cart.rtc_size);
-}
-
-#endif //ifdef CART_CPP

src/cart/cart_st.cpp

@@ -1,62 +0,0 @@
-#ifdef CART_CPP
-
-void Cartridge::load_cart_st(const char *base, const char *slotA, const char *slotB) {
-  uint8_t *data;
-  unsigned size;
-  strcpy(cart.fn, base);
-  strcpy(stA.fn, slotA);
-  strcpy(stB.fn, slotB);
-
-  load_begin(ModeSufamiTurbo);
-  if(load_image(base) == false) return;
-
-  cartinfo_t cartinfo;
-  read_header(cartinfo, cart.rom = image.data, cart.rom_size = image.size);
-  info = cartinfo;
-
-  if(load_image(slotA)) {
-    stA.rom = new(zeromemory) uint8_t[stA.rom_size = 0x100000];
-    memcpy(stA.rom, image.data, min(image.size, stA.rom_size));
-    delete[] image.data;
-
-    load_ram(get_save_filename(slotA, "srm"), stA.ram, stA.ram_size = 0x020000, 0xff);
-  }
-
-  if(load_image(slotB)) {
-    stB.rom = new(zeromemory) uint8_t[stB.rom_size = 0x100000];
-    memcpy(stB.rom, image.data, min(image.size, stB.rom_size));
-    delete[] image.data;
-
-    load_ram(get_save_filename(slotB, "srm"), stB.ram, stB.ram_size = 0x020000, 0xff);
-  }
-
-  load_end();
-
-  //set base filename
-  if(!*slotA && !*slotB) {
-    strcpy(info.filename, cart.fn);
-    get_base_filename(info.filename);
-  } else if(*slotA && !*slotB) {
-    strcpy(info.filename, slotA);
-    get_base_filename(info.filename);
-  } else if(!*slotA && *slotB) {
-    strcpy(info.filename, slotB);
-    get_base_filename(info.filename);
-  } else {
-    char filenameA[PATH_MAX], filenameB[PATH_MAX];
-    strcpy(filenameA, slotA);
-    get_base_filename(filenameA);
-    strcpy(filenameB, slotB);
-    get_base_filename(filenameB);
-    strcpy(info.filename, filenameA);
-    strcat(info.filename, " + ");
-    strcat(info.filename, filenameB);
-  }
-}
-
-void Cartridge::unload_cart_st() {
-  if(stA.ram) save_file(get_save_filename(stA.fn, "srm"), stA.ram, stA.ram_size);
-  if(stB.ram) save_file(get_save_filename(stB.fn, "srm"), stB.ram, stB.ram_size);
-}
-
-#endif //ifdef CART_CPP

src/cc.bat

@@ -1,3 +1,3 @@
-@make platform=win compiler=mingw32-gcc
-::@make platform=win compiler=mingw32-gcc enable_gzip=true enable_jma=true
+@mingw32-make platform=win compiler=mingw32-gcc
+::@mingw32-make platform=win compiler=mingw32-gcc enable_gzip=true enable_jma=true
 @pause

src/cheat/cheat.cpp

@@ -4,10 +4,17 @@ Cheat cheat;
 
 Cheat::cheat_t& Cheat::cheat_t::operator=(const Cheat::cheat_t& source) {
   enabled = source.enabled;
-  addr    = source.addr;
-  data    = source.data;
-  code    = source.code;
-  desc    = source.desc;
+  code = source.code;
+  desc = source.desc;
+  count = source.count;
+
+  addr.reset();
+  data.reset();
+  for(unsigned n = 0; n < count; n++) {
+    addr[n] = source.addr[n];
+    data[n] = source.data[n];
+  }
+
   return *this;
 }
 
@@ -16,14 +23,213 @@ bool Cheat::cheat_t::operator<(const Cheat::cheat_t& source) {
   return strcmp(desc, source.desc) < 0;
 }
 
-/*****
- * string <> binary code translation routines
- * decode() "7e1234:56" ->  0x7e123456
- * encode()  0x7e123456 -> "7e1234:56"
- *****/
+//parse item ("0123-4567+89AB-CDEF"), return cheat_t item
+//return true if code is valid, false otherwise
+bool Cheat::decode(const char *s, Cheat::cheat_t &item) const {
+  item.enabled = false;
+  item.count = 0;
 
-bool Cheat::decode(const char *str, unsigned &addr, uint8 &data, type_t &type) {
-  string t = str;
+  lstring list;
+  list.split("+", s);
+
+  for(unsigned n = 0; n < list.size(); n++) {
+    unsigned addr;
+    uint8_t data;
+    type_t type;
+    if(decode(list[n], addr, data, type) == false) return false;
+
+    item.addr[item.count] = addr;
+    item.data[item.count] = data;
+    item.count++;
+  }
+
+  return true;
+}
+
+//read() is used by MemBus::read() if Cheat::enabled(addr) returns true to look up cheat code.
+//returns true if cheat code was found, false if it was not.
+//when true, cheat code substitution value is stored in data.
+bool Cheat::read(unsigned addr, uint8_t &data) const {
+  addr = mirror_address(addr);
+  for(unsigned i = 0; i < code.size(); i++) {
+    if(enabled(i) == false) continue;
+
+    for(unsigned n = 0; n < code[i].count; n++) {
+      if(addr == mirror_address(code[i].addr[n])) {
+        data = code[i].data[n];
+        return true;
+      }
+    }
+  }
+
+  //code not found, or code is disabled
+  return false;
+}
+
+//==============
+//master control
+//==============
+
+//global cheat system enable/disable:
+//if disabled, *all* cheat codes are disabled;
+//otherwise only individually disabled codes are.
+
+bool Cheat::enabled() const {
+  return cheat_system_enabled;
+}
+
+void Cheat::enable() {
+  cheat_system_enabled = true;
+  cheat_enabled = (cheat_system_enabled && cheat_enabled_code_exists);
+}
+
+void Cheat::disable() {
+  cheat_system_enabled = false;
+  cheat_enabled = false;
+}
+
+//================================
+//cheat list manipulation routines
+//================================
+
+bool Cheat::add(bool enable, const char *code_, const char *desc_) {
+  cheat_t item;
+  if(decode(code_, item) == false) return false;
+
+  unsigned i = code.size();
+  code[i] = item;
+  code[i].enabled = enable;
+  code[i].desc = desc_;
+  code[i].code = code_;
+  encode_description(code[i].desc);
+  update(code[i]);
+
+  update_cheat_status();
+  return true;
+}
+
+bool Cheat::edit(unsigned i, bool enable, const char *code_, const char *desc_) {
+  cheat_t item;
+  if(decode(code_, item) == false) return false;
+
+  //disable current code and clear from code lookup table
+  code[i].enabled = false;
+  update(code[i]);
+
+  code[i] = item;
+  code[i].enabled = enable;
+  code[i].desc = desc_;
+  code[i].code = code_;
+  encode_description(code[i].desc);
+  update(code[i]);
+
+  update_cheat_status();
+  return true;
+}
+
+bool Cheat::remove(unsigned i) {
+  unsigned size = code.size();
+  if(i >= size) return false;  //also verifies size cannot be < 1
+
+  for(unsigned n = i; n < size - 1; n++) code[n] = code[n + 1];
+  code.resize(size - 1);
+
+  update_cheat_status();
+  return true;
+}
+
+bool Cheat::get(unsigned i, cheat_t &item) const {
+  if(i >= code.size()) return false;
+
+  item = code[i];
+  decode_description(item.desc);
+  return true;
+}
+
+//==============================
+//cheat status modifier routines
+//==============================
+
+bool Cheat::enabled(unsigned i) const {
+  return (i < code.size() ? code[i].enabled : false);
+}
+
+void Cheat::enable(unsigned i) {
+  if(i >= code.size()) return;
+
+  code[i].enabled = true;
+  update(code[i]);
+  update_cheat_status();
+}
+
+void Cheat::disable(unsigned i) {
+  if(i >= code.size()) return;
+
+  code[i].enabled = false;
+  update(code[i]);
+  update_cheat_status();
+}
+
+//===============================
+//cheat file load / save routines
+//
+//file format:
+//"description", status, nnnn-nnnn[+nnnn-nnnn...]\r\n
+//...
+//===============================
+
+bool Cheat::load(const char *fn) {
+  string data;
+  if(!data.readfile(fn)) return false;
+  data.replace("\r\n", "\n");
+  data.qreplace(" ", "");
+
+  lstring line;
+  line.split("\n", data);
+  for(unsigned i = 0; i < line.size(); i++) {
+    lstring part;
+    part.qsplit(",", line[i]);
+    if(part.size() != 3) continue;
+    trim(part[0], "\"");
+    add(part[1] == "enabled", /* code = */ part[2], /* desc = */ part[0]);
+  }
+
+  return true;
+}
+
+bool Cheat::save(const char *fn) const {
+  file fp;
+  if(!fp.open(fn, file::mode_write)) return false;
+  for(unsigned i = 0; i < code.size(); i++) {
+    fp.print(string()
+      << "\"" << code[i].desc << "\", "
+      << (code[i].enabled ? "enabled, " : "disabled, ")
+      << code[i].code << "\r\n");
+  }
+  fp.close();
+  return true;
+}
+
+void Cheat::clear() {
+  cheat_enabled_code_exists = false;
+  memset(mask, 0, 0x200000);
+  code.reset();
+}
+
+Cheat::Cheat() : cheat_system_enabled(true) {
+  clear();
+}
+
+//==================
+//internal functions
+//==================
+
+//string <> binary code translation routines
+//decode() "7e123456" -> 0x7e123456
+//encode() 0x7e123456 -> "7e123456"
+
+bool Cheat::decode(const char *s, unsigned &addr, uint8_t &data, type_t &type) const {
+  string t = s;
   strlower(t);
 
   #define ischr(n) ((n >= '0' && n <= '9') || (n >= 'a' && n <= 'f'))
@@ -51,18 +257,18 @@ bool Cheat::decode(const char *str, unsigned &addr, uint8 &data, type_t &type) {
     //8421 8421 8421 8421 8421 8421
     //abcd efgh ijkl mnop qrst uvwx
     //ijkl qrst opab cduv wxef ghmn
-    addr = (!!(r & 0x002000) << 23) | (!!(r & 0x001000) << 22) |
-           (!!(r & 0x000800) << 21) | (!!(r & 0x000400) << 20) |
-           (!!(r & 0x000020) << 19) | (!!(r & 0x000010) << 18) |
-           (!!(r & 0x000008) << 17) | (!!(r & 0x000004) << 16) |
-           (!!(r & 0x800000) << 15) | (!!(r & 0x400000) << 14) |
-           (!!(r & 0x200000) << 13) | (!!(r & 0x100000) << 12) |
-           (!!(r & 0x000002) << 11) | (!!(r & 0x000001) << 10) |
-           (!!(r & 0x008000) <<  9) | (!!(r & 0x004000) <<  8) |
-           (!!(r & 0x080000) <<  7) | (!!(r & 0x040000) <<  6) |
-           (!!(r & 0x020000) <<  5) | (!!(r & 0x010000) <<  4) |
-           (!!(r & 0x000200) <<  3) | (!!(r & 0x000100) <<  2) |
-           (!!(r & 0x000080) <<  1) | (!!(r & 0x000040) <<  0);
+    addr = (!!(r & 0x002000) << 23) | (!!(r & 0x001000) << 22)
+         | (!!(r & 0x000800) << 21) | (!!(r & 0x000400) << 20)
+         | (!!(r & 0x000020) << 19) | (!!(r & 0x000010) << 18)
+         | (!!(r & 0x000008) << 17) | (!!(r & 0x000004) << 16)
+         | (!!(r & 0x800000) << 15) | (!!(r & 0x400000) << 14)
+         | (!!(r & 0x200000) << 13) | (!!(r & 0x100000) << 12)
+         | (!!(r & 0x000002) << 11) | (!!(r & 0x000001) << 10)
+         | (!!(r & 0x008000) <<  9) | (!!(r & 0x004000) <<  8)
+         | (!!(r & 0x080000) <<  7) | (!!(r & 0x040000) <<  6)
+         | (!!(r & 0x020000) <<  5) | (!!(r & 0x010000) <<  4)
+         | (!!(r & 0x000200) <<  3) | (!!(r & 0x000100) <<  2)
+         | (!!(r & 0x000080) <<  1) | (!!(r & 0x000040) <<  0);
     data = r >> 24;
     return true;
   } else {
@@ -70,43 +276,54 @@ bool Cheat::decode(const char *str, unsigned &addr, uint8 &data, type_t &type) {
   }
 }
 
-bool Cheat::encode(string &str, unsigned addr, uint8 data, type_t type) {
+bool Cheat::encode(string &s, unsigned addr, uint8_t data, type_t type) const {
   char t[16];
 
   if(type == ProActionReplay) {
-    sprintf(t, "%0.6x:%0.2x", addr, data);
-    str = t;
+    sprintf(t, "%.6x%.2x", addr, data);
+    s = t;
     return true;
   } else if(type == GameGenie) {
     unsigned r = addr;
-    addr = (!!(r & 0x008000) << 23) | (!!(r & 0x004000) << 22) |
-           (!!(r & 0x002000) << 21) | (!!(r & 0x001000) << 20) |
-           (!!(r & 0x000080) << 19) | (!!(r & 0x000040) << 18) |
-           (!!(r & 0x000020) << 17) | (!!(r & 0x000010) << 16) |
-           (!!(r & 0x000200) << 15) | (!!(r & 0x000100) << 14) |
-           (!!(r & 0x800000) << 13) | (!!(r & 0x400000) << 12) |
-           (!!(r & 0x200000) << 11) | (!!(r & 0x100000) << 10) |
-           (!!(r & 0x000008) <<  9) | (!!(r & 0x000004) <<  8) |
-           (!!(r & 0x000002) <<  7) | (!!(r & 0x000001) <<  6) |
-           (!!(r & 0x080000) <<  5) | (!!(r & 0x040000) <<  4) |
-           (!!(r & 0x020000) <<  3) | (!!(r & 0x010000) <<  2) |
-           (!!(r & 0x000800) <<  1) | (!!(r & 0x000400) <<  0);
-    sprintf(t, "%0.2x%0.2x-%0.4x", data, addr >> 16, addr & 0xffff);
+    addr = (!!(r & 0x008000) << 23) | (!!(r & 0x004000) << 22)
+         | (!!(r & 0x002000) << 21) | (!!(r & 0x001000) << 20)
+         | (!!(r & 0x000080) << 19) | (!!(r & 0x000040) << 18)
+         | (!!(r & 0x000020) << 17) | (!!(r & 0x000010) << 16)
+         | (!!(r & 0x000200) << 15) | (!!(r & 0x000100) << 14)
+         | (!!(r & 0x800000) << 13) | (!!(r & 0x400000) << 12)
+         | (!!(r & 0x200000) << 11) | (!!(r & 0x100000) << 10)
+         | (!!(r & 0x000008) <<  9) | (!!(r & 0x000004) <<  8)
+         | (!!(r & 0x000002) <<  7) | (!!(r & 0x000001) <<  6)
+         | (!!(r & 0x080000) <<  5) | (!!(r & 0x040000) <<  4)
+         | (!!(r & 0x020000) <<  3) | (!!(r & 0x010000) <<  2)
+         | (!!(r & 0x000800) <<  1) | (!!(r & 0x000400) <<  0);
+    sprintf(t, "%.2x%.2x-%.4x", data, addr >> 16, addr & 0xffff);
     strtr(t, "0123456789abcdef", "df4709156bc8a23e");
-    str = t;
+    s = t;
     return true;
   } else {
     return false;
   }
 }
 
-/*****
- * address lookup table manipulation and mirroring
- * mirror_address() 0x000000 -> 0x7e0000
- * set() enable specified address, mirror accordingly
- * clear() disable specified address, mirror accordingly
- *****/
+//speed up S-CPU memory reads by disabling cheat code lookup when either:
+//a) cheat system is disabled by user, or b) no enabled cheat codes exist
+void Cheat::update_cheat_status() {
+  for(unsigned i = 0; i < code.size(); i++) {
+    if(code[i].enabled) {
+      cheat_enabled_code_exists = true;
+      cheat_enabled = (cheat_system_enabled && cheat_enabled_code_exists);
+      return;
+    }
+  }
+  cheat_enabled_code_exists = false;
+  cheat_enabled = false;
+}
 
+//address lookup table manipulation and mirroring
+//mirror_address() 0x000000 -> 0x7e0000
+//set() enable specified address, mirror accordingly
+//clear() disable specified address, mirror accordingly
 unsigned Cheat::mirror_address(unsigned addr) const {
   if((addr & 0x40e000) != 0x0000) return addr;
   //8k WRAM mirror
@@ -114,6 +331,14 @@ unsigned Cheat::mirror_address(unsigned addr) const {
   return (0x7e0000 + (addr & 0x1fff));
 }
 
+//updates mask[] table enabled bits;
+//must be called after modifying item.enabled state.
+void Cheat::update(const cheat_t &item) {
+  for(unsigned n = 0; n < item.count; n++) {
+    (item.enabled) ? set(item.addr[n]) : clear(item.addr[n]);
+  }
+}
+
 void Cheat::set(unsigned addr) {
   addr = mirror_address(addr);
 
@@ -136,7 +361,7 @@ void Cheat::clear(unsigned addr) {
   //if there is more than one cheat code using the same address,
   //(eg with a different override value) then do not clear code
   //lookup table entry.
-  uint8 r;
+  uint8_t r;
   if(read(addr, r) == true) return;
 
   mask[addr >> 3] &= ~(1 << (addr & 7));
@@ -152,185 +377,16 @@ void Cheat::clear(unsigned addr) {
   }
 }
 
-/*****
- * read() is used by MemBus::read() if Cheat::enabled(addr)
- * returns true to look up cheat code.
- * returns true if cheat code was found, false if it was not.
- * when true, cheat code substitution value is stored in data.
- *****/
+//these two functions are used to safely store description text inside .cfg file format.
 
-bool Cheat::read(unsigned addr, uint8 &data) const {
-  addr = mirror_address(addr);
-  for(unsigned i = 0; i < code.size(); i++) {
-    if(enabled(i) == false) continue;
-    if(addr == mirror_address(code[i].addr)) {
-      data = code[i].data;
-      return true;
-    }
-  }
-  //code not found, or code is disabled
-  return false;
+string& Cheat::encode_description(string &desc) const {
+  desc.replace("\"", "\\q");
+  desc.replace("\n", "\\n");
+  return desc;
 }
 
-/*****
- * update_cheat_status() will scan to see if any codes are
- * enabled. if any are, make sure the cheat system is on.
- * otherwise, turn cheat system off to speed up emulation.
- *****/
-
-void Cheat::update_cheat_status() {
-  for(unsigned i = 0; i < code.size(); i++) {
-    if(code[i].enabled) {
-      cheat_system_enabled = true;
-      return;
-    }
-  }
-  cheat_system_enabled = false;
-}
-
-/*****
- * cheat list manipulation routines
- *****/
-
-bool Cheat::add(bool enable, const char *code_, const char *desc_) {
-  unsigned addr;
-  uint8    data;
-  type_t   type;
-  if(decode(code_, addr, data, type) == false) return false;
-
-  unsigned n = code.size();
-  code[n].enabled = enable;
-  code[n].addr = addr;
-  code[n].data = data;
-  code[n].code = code_;
-  code[n].desc = desc_;
-  (enable) ? set(addr) : clear(addr);
-
-  update_cheat_status();
-  return true;
-}
-
-bool Cheat::edit(unsigned n, bool enable, const char *code_, const char *desc_) {
-  unsigned addr;
-  uint8    data;
-  type_t   type;
-  if(decode(code_, addr, data, type) == false) return false;
-
-  //disable current code and clear from code lookup table
-  code[n].enabled = false;
-  clear(code[n].addr);
-
-  //update code and enable in code lookup table
-  code[n].enabled = enable;
-  code[n].addr = addr;
-  code[n].data = data;
-  code[n].code = code_;
-  code[n].desc = desc_;
-  set(addr);
-
-  update_cheat_status();
-  return true;
-}
-
-bool Cheat::remove(unsigned n) {
-  unsigned size = code.size();
-  if(n >= size) return false; //also verifies size cannot be < 1
-
-  for(unsigned i = n; i < size - 1; i++) code[i] = code[i + 1];
-  code.resize(size - 1);
-
-  update_cheat_status();
-  return true;
-}
-
-bool Cheat::get(unsigned n, cheat_t &cheat) const {
-  if(n >= code.size()) return false;
-
-  cheat = code[n];
-  return true;
-}
-
-/*****
- * code status modifier routines
- *****/
-
-bool Cheat::enabled(unsigned n) const {
-  return (n < code.size()) ? code[n].enabled : false;
-}
-
-void Cheat::enable(unsigned n) {
-  if(n >= code.size()) return;
-
-  code[n].enabled = true;
-  set(code[n].addr);
-  update_cheat_status();
-}
-
-void Cheat::disable(unsigned n) {
-  if(n >= code.size()) return;
-
-  code[n].enabled = false;
-  clear(code[n].addr);
-  update_cheat_status();
-}
-
-/*****
- * cheat file manipulation routines
- *****/
-
-/* file format: */
-/* nnnn-nnnn = status, "description" \r\n */
-/* ... */
-
-bool Cheat::load(const char *fn) {
-  string data;
-  if(!fread(data, fn)) return false;
-  replace(data, "\r\n", "\n");
-  qreplace(data, "=", ",");
-  qreplace(data, " ", "");
-
-  lstring line;
-  split(line, "\n", data);
-  for(unsigned i = 0; i < ::count(line); i++) {
-    lstring part;
-    split(part, ",", line[i]);
-    if(::count(part) != 3) continue;
-    trim(part[2], "\"");
-    add(part[1] == "enabled", part[0], part[2]);
-  }
-
-  return true;
-}
-
-bool Cheat::save(const char *fn) const {
-  file fp;
-  if(!fp.open(fn, file::mode_write)) return false;
-  for(unsigned i = 0; i < code.size(); i++) {
-    fp.print(string()
-      << code[i].code << " = "
-      << (code[i].enabled ? "enabled" : "disabled") << ", "
-      << "\"" << code[i].desc << "\""
-      << "\r\n");
-  }
-  fp.close();
-  return true;
-}
-
-void Cheat::sort() {
-  if(code.size() <= 1) return;  //nothing to sort?
-  cheat_t *buffer = new cheat_t[code.size()];
-  for(unsigned i = 0; i < code.size(); i++) buffer[i] = code[i];
-  nall::sort(buffer, code.size());
-  for(unsigned i = 0; i < code.size(); i++) code[i] = buffer[i];
-  delete[] buffer;
-}
-
-void Cheat::clear() {
-  cheat_system_enabled = false;
-  memset(mask, 0, 0x200000);
-  code.reset();
-}
-
-Cheat::Cheat() {
-  clear();
+string& Cheat::decode_description(string &desc) const {
+  desc.replace("\\q", "\"");
+  desc.replace("\\n", "\n");
+  return desc;
 }

src/cheat/cheat.hpp

@@ -6,50 +6,64 @@ public:
   };
 
   struct cheat_t {
-    bool     enabled;
-    unsigned addr;
-    uint8    data;
-    string   code;
-    string   desc;
+    bool enabled;
+    string code;
+    string desc;
+
+    unsigned count;
+    array<unsigned> addr;
+    array<uint8_t> data;
 
     cheat_t& operator=(const cheat_t&);
     bool operator<(const cheat_t&);
   };
 
-  static bool decode(const char *str, unsigned &addr, uint8 &data, type_t &type);
-  static bool encode(string &str, unsigned addr, uint8 data, type_t type);
+  bool decode(const char *s, cheat_t &item) const;
+  bool read(unsigned addr, uint8_t &data) const;
+
+  bool enabled() const;
+  void enable();
+  void disable();
 
-  inline bool enabled() const { return cheat_system_enabled; }
   inline unsigned count() const { return code.size(); }
-  inline bool exists(unsigned addr) const { return bool(mask[addr >> 3] & 1 << (addr & 7)); }
-
-  bool read(unsigned addr, uint8 &data) const;
+  inline bool active() const { return cheat_enabled; }
+  inline bool exists(unsigned addr) const { return mask[addr >> 3] & 1 << (addr & 7); }
 
   bool add(bool enable, const char *code, const char *desc);
-  bool edit(unsigned n, bool enable, const char *code, const char *desc);
-  bool get(unsigned n, cheat_t &cheat) const;
-  bool remove(unsigned n);
-  bool enabled(unsigned n) const;
-  void enable(unsigned n);
-  void disable(unsigned n);
+  bool edit(unsigned i, bool enable, const char *code, const char *desc);
+  bool remove(unsigned i);
+  bool get(unsigned i, cheat_t &item) const;
+
+  bool enabled(unsigned i) const;
+  void enable(unsigned i);
+  void disable(unsigned i);
 
   bool load(const char *fn);
   bool save(const char *fn) const;
-
-  void sort();
   void clear();
 
   Cheat();
 
 private:
+  bool cheat_enabled;  //cheat_enabled == (cheat_enabled_code_exists && cheat_system_enabled);
+  bool cheat_enabled_code_exists;
   bool cheat_system_enabled;
-  uint8 mask[0x200000];
+
+  uint8_t mask[0x200000];
   vector<cheat_t> code;
 
+  bool decode(const char *str, unsigned &addr, uint8_t &data, type_t &type) const;
+  bool encode(string &str, unsigned addr, uint8_t data, type_t type) const;
+
   void update_cheat_status();
   unsigned mirror_address(unsigned addr) const;
+
+  void update(const cheat_t& item);
   void set(unsigned addr);
   void clear(unsigned addr);
+
+  string& encode_description(string &desc) const;
+  string& decode_description(string &desc) const;
 };
 
 extern Cheat cheat;

src/chip/bsx/bsx.cpp

@@ -1,6 +1,8 @@
-#include <../base.hpp>
+#include <../base.hpp>
+#include <../cart/cart.hpp>
 #define BSX_CPP
 
+#include "bsx.hpp"
 #include "bsx_base.cpp"
 #include "bsx_cart.cpp"
 #include "bsx_flash.cpp"

src/chip/bsx/bsx.hpp

@@ -5,8 +5,8 @@ public:
   void power();
   void reset();
 
-  uint8 mmio_read(uint addr);
-  void mmio_write(uint addr, uint8 data);
+  uint8 mmio_read(unsigned addr);
+  void mmio_write(unsigned addr, uint8 data);
 
 private:
   struct {
@@ -29,8 +29,8 @@ public:
   void power();
   void reset();
 
-  uint8 mmio_read(uint addr);
-  void mmio_write(uint addr, uint8 data);
+  uint8 mmio_read(unsigned addr);
+  void mmio_write(unsigned addr, uint8 data);
 
   MappedRAM sram;
   MappedRAM psram;
@@ -56,13 +56,13 @@ public:
   void power();
   void reset();
 
-  uint size();
-  uint8 read(uint addr);
-  void write(uint addr, uint8 data);
+  unsigned size();
+  uint8 read(unsigned addr);
+  void write(unsigned addr, uint8 data);
 
 private:
   struct {
-    uint command;
+    unsigned command;
     uint8 write_old;
     uint8 write_new;
 

src/chip/bsx/bsx_base.cpp

@@ -15,7 +15,7 @@ void BSXBase::reset() {
   memset(&regs, 0x00, sizeof regs);
 }
 
-uint8 BSXBase::mmio_read(uint addr) {
+uint8 BSXBase::mmio_read(unsigned addr) {
   addr &= 0xffff;
 
   switch(addr) {
@@ -28,7 +28,7 @@ uint8 BSXBase::mmio_read(uint addr) {
     case 0x2190: return regs.r2190;
 
     case 0x2192: {
-    uint counter = regs.r2192_counter++;
+      unsigned counter = regs.r2192_counter++;
       if(regs.r2192_counter >= 18) regs.r2192_counter = 0;
 
       if(counter == 0) {
@@ -73,7 +73,7 @@ uint8 BSXBase::mmio_read(uint addr) {
   return cpu.regs.mdr;
 }
 
-void BSXBase::mmio_write(uint addr, uint8 data) {
+void BSXBase::mmio_write(unsigned addr, uint8 data) {
   addr &= 0xffff;
 
   switch(addr) {
@@ -134,4 +134,4 @@ void BSXBase::mmio_write(uint addr, uint8 data) {
   }
 }
 
-#endif //ifdef BSX_CPP
+#endif

src/chip/bsx/bsx_cart.cpp

@@ -12,7 +12,7 @@ void BSXCart::power() {
 }
 
 void BSXCart::reset() {
-  for(uint i = 0; i < 16; i++) regs.r[i] = 0x00;
+  for(unsigned i = 0; i < 16; i++) regs.r[i] = 0x00;
   regs.r[0x07] = 0x80;
   regs.r[0x08] = 0x80;
 
@@ -57,7 +57,7 @@ void BSXCart::update_memory_map() {
   bus.map(Bus::MapLinear, 0x70, 0x77, 0x0000, 0xffff, psram);
 }
 
-uint8 BSXCart::mmio_read(uint addr) {
+uint8 BSXCart::mmio_read(unsigned addr) {
   if((addr & 0xf0ffff) == 0x005000) { //$[00-0f]:5000 MMIO
     uint8 n = (addr >> 16) & 15;
     return regs.r[n];
@@ -70,7 +70,7 @@ uint8 BSXCart::mmio_read(uint addr) {
   return 0x00;
 }
 
-void BSXCart::mmio_write(uint addr, uint8 data) {
+void BSXCart::mmio_write(unsigned addr, uint8 data) {
   if((addr & 0xf0ffff) == 0x005000) { //$[00-0f]:5000 MMIO
     uint8 n = (addr >> 16) & 15;
     regs.r[n] = data;
@@ -96,4 +96,4 @@ BSXCart::~BSXCart() {
   delete[] psram_data;
 }
 
-#endif //ifdef BSX_CPP
+#endif

src/chip/bsx/bsx_flash.cpp

@@ -17,11 +17,11 @@ void BSXFlash::reset() {
   regs.write_enable = false;
 }
 
-uint BSXFlash::size() {
+unsigned BSXFlash::size() {
   return memory::bscram.size();
 }
 
-uint8 BSXFlash::read(uint addr) {
+uint8 BSXFlash::read(unsigned addr) {
   if(addr == 0x0002) {
     if(regs.flash_enable) return 0x80;
   }
@@ -48,7 +48,7 @@ uint8 BSXFlash::read(uint addr) {
   return memory::bscram.read(addr);
 }
 
-void BSXFlash::write(uint addr, uint8 data) {
+void BSXFlash::write(unsigned addr, uint8 data) {
 //there exist both read-only and read-write BS-X flash cartridges ...
 //unfortunately, the vendor info is not stored inside memory dumps
 //of BS-X flashcarts, so it is impossible to determine whether a
@@ -110,4 +110,4 @@ void BSXFlash::write(uint addr, uint8 data) {
   }
 }
 
-#endif //ifdef BSX_CPP
+#endif

src/chip/cx4/cx4.cpp

@@ -8,6 +8,7 @@
 #include <../base.hpp>
 #define CX4_CPP
 
+#include "cx4.hpp"
 #include "cx4data.cpp"
 #include "cx4fn.cpp"
 #include "cx4oam.cpp"
@@ -78,7 +79,7 @@ uint16 dest, count;
   }
 }
 
-void Cx4::write(uint addr, uint8 data) {
+void Cx4::write(unsigned addr, uint8 data) {
   addr &= 0x1fff;
 
   if(addr < 0x0c00) {
@@ -160,7 +161,7 @@ void Cx4::writel(uint16 addr, uint32 data) {
   write(addr + 2, data >> 16);
 }
 
-uint8 Cx4::read(uint addr) {
+uint8 Cx4::read(unsigned addr) {
   addr &= 0x1fff;
 
   if(addr < 0x0c00) {

src/chip/cx4/cx4.hpp

@@ -90,8 +90,8 @@ public:
   void   power();
   void   reset();
 
-  uint8  read (uint addr);
-  void   write(uint addr, uint8 data);
+  uint8  read (unsigned addr);
+  void   write(unsigned addr, uint8 data);
 };
 
 extern Cx4 cx4;

src/chip/cx4/cx4data.cpp

@@ -184,4 +184,4 @@ const int16 Cx4::CosTable[512] = {
    32610,  32647,  32679,  32706,  32728,  32745,  32758,  32765
 };
 
-#endif //ifdef CX4_CPP
+#endif

src/chip/cx4/cx4fn.cpp

@@ -243,4 +243,4 @@ uint8 bit    = 0x80;
   }
 }
 
-#endif //ifdef CX4_CPP
+#endif

src/chip/cx4/cx4oam.cpp

@@ -220,4 +220,4 @@ uint16 mask2   = 0x3f3f;
   }
 }
 
-#endif //ifdef CX4_CPP
+#endif

src/chip/cx4/cx4ops.cpp

@@ -223,4 +223,4 @@ void Cx4::op89() {
   str(1, 0xffffff);
 }
 
-#endif //ifdef CX4_CPP
+#endif

src/chip/dsp1/dsp1.cpp

@@ -1,6 +1,8 @@
-#include <../base.hpp>
+#include <../base.hpp>
+#include <../cart/cart.hpp>
 #define DSP1_CPP
 
+#include "dsp1.hpp"
 #include "dsp1emu.cpp"
 
 void DSP1::init() {}
@@ -26,7 +28,7 @@ void DSP1::reset() {
  * of expected ranges
  *****/
 bool DSP1::addr_decode(uint16 addr) {
-  switch(cartridge.info.dsp1_mapper) {
+  switch(cartridge.dsp1_mapper()) {
     case Cartridge::DSP1LoROM1MB: {
     //$[20-3f]:[8000-bfff] = DR, $[20-3f]:[c000-ffff] = SR
       return (addr >= 0xc000);
@@ -46,11 +48,11 @@ bool DSP1::addr_decode(uint16 addr) {
   return 0;
 }
 
-uint8 DSP1::read(uint addr) {
+uint8 DSP1::read(unsigned addr) {
   return (addr_decode(addr) == 0) ? dsp1.getDr() : dsp1.getSr();
 }
 
-void DSP1::write(uint addr, uint8 data) {
+void DSP1::write(unsigned addr, uint8 data) {
   if(addr_decode(addr) == 0) {
     dsp1.setDr(data);
   }

src/chip/dsp1/dsp1.hpp

@@ -11,8 +11,8 @@ public:
   void power();
   void reset();
 
-  uint8 read(uint addr);
-  void write(uint addr, uint8 data);
+  uint8 read(unsigned addr);
+  void write(unsigned addr, uint8 data);
 };
 
 extern DSP1 dsp1;

src/chip/dsp1/dsp1emu.cpp

@@ -1622,4 +1622,4 @@ const int16 Dsp1::SinTable[256] = {
 
 //////////////////////////////////////////////////////////////////
 
-#endif //ifdef DSP1_CPP
+#endif

src/chip/dsp2/dsp2.cpp

@@ -1,6 +1,7 @@
 #include <../base.hpp>
 #define DSP2_CPP
 
+#include "dsp2.hpp"
 #include "dsp2_op.cpp"
 
 void DSP2::init() {}
@@ -29,8 +30,8 @@ void DSP2::reset() {
   status.op0dinlen       = 0;
 }
 
-uint8 DSP2::read(uint addr) {
-uint8 r = 0xff;
+uint8 DSP2::read(unsigned addr) {
+  uint8 r = 0xff;
   if(status.out_count) {
     r = status.output[status.out_index++];
     status.out_index &= 511;
@@ -41,7 +42,7 @@ uint8 r = 0xff;
   return r;
 }
 
-void DSP2::write(uint addr, uint8 data) {
+void DSP2::write(unsigned addr, uint8 data) {
   if(status.waiting_for_command) {
     status.command  = data;
     status.in_index = 0;

src/chip/dsp2/dsp2.hpp

@@ -1,10 +1,10 @@
 class DSP2 : public Memory {
 public:
   struct {
-    bool   waiting_for_command;
-    uint   command;
-    uint   in_count,  in_index;
-    uint   out_count, out_index;
+    bool waiting_for_command;
+    unsigned command;
+    unsigned in_count,  in_index;
+    unsigned out_count, out_index;
 
     uint8  parameters[512];
     uint8  output[512];
@@ -26,8 +26,8 @@ public:
   void power();
   void reset();
 
-  uint8 read(uint addr);
-  void write(uint addr, uint8 data);
+  uint8 read(unsigned addr);
+  void write(unsigned addr, uint8 data);
 
   DSP2();
   ~DSP2();

src/chip/dsp2/dsp2_op.cpp

@@ -174,4 +174,4 @@ uint8  pixelarray[512];
   }
 }
 
-#endif //ifdef DSP2_CPP
+#endif

src/chip/dsp3/dsp3.cpp

@@ -1,6 +1,7 @@
 #include <../base.hpp>
 #define DSP3_CPP
 
+#include "dsp3.hpp"
 namespace DSP3i {
   #define bool8 uint8
   #include "dsp3emu.c"
@@ -21,13 +22,13 @@ void DSP3::reset() {
   DSP3i::DSP3_Reset();
 }
 
-uint8 DSP3::read(uint addr) {
+uint8 DSP3::read(unsigned addr) {
   DSP3i::dsp3_address = addr & 0xffff;
   DSP3i::DSP3GetByte();
   return DSP3i::dsp3_byte;
 }
 
-void DSP3::write(uint addr, uint8 data) {
+void DSP3::write(unsigned addr, uint8 data) {
   DSP3i::dsp3_address = addr & 0xffff;
   DSP3i::dsp3_byte = data;
   DSP3i::DSP3SetByte();

src/chip/dsp3/dsp3.hpp

@@ -5,8 +5,8 @@ public:
   void power();
   void reset();
 
-  uint8 read (uint addr);
-  void  write(uint addr, uint8 data);
+  uint8 read (unsigned addr);
+  void  write(unsigned addr, uint8 data);
 };
 
 extern DSP3 dsp3;

src/chip/dsp3/dsp3emu.c

@@ -1143,4 +1143,4 @@ void InitDSP3()
   DSP3_Reset();
 }
 
-#endif //ifdef DSP3_CPP
+#endif

src/chip/dsp4/dsp4.cpp

@@ -1,6 +1,7 @@
 #include <../base.hpp>
 #define DSP4_CPP
 
+#include "dsp4.hpp"
 namespace DSP4i {
   inline uint16 READ_WORD(uint8 *addr) {
     return (addr[0]) + (addr[1] << 8);
@@ -34,7 +35,7 @@ void DSP4::reset() {
   DSP4i::InitDSP4();
 }
 
-uint8 DSP4::read(uint addr) {
+uint8 DSP4::read(unsigned addr) {
   addr &= 0xffff;
   if(addr < 0xc000) {
     DSP4i::dsp4_address = addr;
@@ -44,7 +45,7 @@ uint8 DSP4::read(uint addr) {
   return 0x80;
 }
 
-void DSP4::write(uint addr, uint8 data) {
+void DSP4::write(unsigned addr, uint8 data) {
   addr &= 0xffff;
   if(addr < 0xc000) {
     DSP4i::dsp4_address = addr;

src/chip/dsp4/dsp4.hpp

@@ -5,8 +5,8 @@ public:
   void power();
   void reset();
 
-  uint8 read (uint addr);
-  void  write(uint addr, uint8 data);
+  uint8 read (unsigned addr);
+  void  write(unsigned addr, uint8 data);
 };
 
 extern DSP4 dsp4;

src/chip/dsp4/dsp4emu.c

@@ -2147,4 +2147,4 @@ void DSP4GetByte()
   }
 }
 
-#endif //ifdef DSP4_CPP
+#endif

src/chip/obc1/obc1.cpp

@@ -1,4 +1,6 @@
 #include <../base.hpp>
+#include <../cart/cart.hpp>
+#include "obc1.hpp"
 
 void OBC1::init() {}
 void OBC1::enable() {}

src/chip/sdd1/sdd1.cpp

@@ -1,6 +1,8 @@
-#include <../base.hpp>
+#include <../base.hpp>
+#include <../cart/cart.hpp>
 #define SDD1_CPP
 
+#include "sdd1.hpp"
 #include "sdd1emu.cpp"
 
 void SDD1::init() {}
@@ -42,7 +44,7 @@ void SDD1::reset() {
   bus.map(Bus::MapDirect, 0xc0, 0xff, 0x0000, 0xffff, *this);
 }
 
-uint8 SDD1::mmio_read(uint addr) {
+uint8 SDD1::mmio_read(unsigned addr) {
   addr &= 0xffff;
 
   if((addr & 0x4380) == 0x4300) {
@@ -59,7 +61,7 @@ uint8 SDD1::mmio_read(uint addr) {
   return cpu.regs.mdr;
 }
 
-void SDD1::mmio_write(uint addr, uint8 data) {
+void SDD1::mmio_write(unsigned addr, uint8 data) {
   addr &= 0xffff;
 
   if((addr & 0x4380) == 0x4300) {

src/chip/sdd1/sdd1emu.cpp

@@ -448,4 +448,4 @@ SDD1emu::SDD1emu() :
 
 ///////////////////////////////////////////////////////////
 
-#endif //ifdef SDD1_CPP
+#endif

src/chip/spc7110/spc7110.cpp

@@ -1,6 +1,8 @@
 #include <../base.hpp>
+#include <../cart/cart.hpp>
 #define SPC7110_CPP
 
+#include "spc7110.hpp"
 #include "decomp.cpp"
 
 const unsigned SPC7110::months[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
@@ -8,7 +10,7 @@ const unsigned SPC7110::months[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 3
 void SPC7110::init() {}
 
 void SPC7110::enable() {
-  uint16_t limit = (cartridge.info.spc7110rtc ? 0x4842 : 0x483f);
+  uint16_t limit = (cartridge.has_spc7110rtc() ? 0x4842 : 0x483f);
   for(uint16_t i = 0x4800; i <= limit; i++) memory::mmio.map(i, *this);
 }
 
@@ -72,7 +74,7 @@ void SPC7110::reset() {
   r4841 = 0x00;
   r4842 = 0x00;
 
-  if(cartridge.info.spc7110rtc) {
+  if(cartridge.has_spc7110rtc()) {
     rtc_state = RTCS_Inactive;
     rtc_mode  = RTCM_Linear;
     rtc_index = 0;
@@ -92,18 +94,30 @@ void SPC7110::set_data_pointer(unsigned addr) { r4811 = addr; r4812 = addr >> 8;
 void SPC7110::set_data_adjust(unsigned addr)  { r4814 = addr; r4815 = addr >> 8; }
 
 void SPC7110::update_time(int offset) {
-  time_t rtc_time;
-  rtc_time  = memory::cartrtc.read(16);
-  rtc_time |= memory::cartrtc.read(17) << 8;
-  rtc_time |= memory::cartrtc.read(18) << 16;
-  rtc_time |= memory::cartrtc.read(19) << 24;
+  time_t rtc_time
+  = (memory::cartrtc.read(16) <<  0)
+  | (memory::cartrtc.read(17) <<  8)
+  | (memory::cartrtc.read(18) << 16)
+  | (memory::cartrtc.read(19) << 24);
+  time_t current_time = time(0) - offset;
+
+  //sizeof(time_t) is platform-dependent; though memory::cartrtc needs to be platform-agnostic.
+  //yet platforms with 32-bit signed time_t will overflow every ~68 years. handle this by
+  //accounting for overflow at the cost of 1-bit precision (to catch underflow). this will allow
+  //memory::cartrtc timestamp to remain valid for up to ~34 years from the last update, even if
+  //time_t overflows. calculation should be valid regardless of number representation, time_t size,
+  //or whether time_t is signed or unsigned.
+  time_t diff
+  = (current_time >= rtc_time)
+  ? (current_time - rtc_time)
+  : (std::numeric_limits<time_t>::max() - rtc_time + current_time + 1);  //compensate for overflow
+  if(diff > std::numeric_limits<time_t>::max() / 2) diff = 0;            //compensate for underflow
 
   bool update = true;
-  if(memory::cartrtc.read(13) & 1) update = false; //do not update if CR0 timer disable flag is set
-  if(memory::cartrtc.read(15) & 3) update = false; //do not update if CR2 timer disable flags are set
+  if(memory::cartrtc.read(13) & 1) update = false;  //do not update if CR0 timer disable flag is set
+  if(memory::cartrtc.read(15) & 3) update = false;  //do not update if CR2 timer disable flags are set
 
-  time_t current_time = time(0) - offset;
-  if(update && current_time > rtc_time) {
+  if(diff > 0 && update == true) {
     unsigned second  = memory::cartrtc.read( 0) + memory::cartrtc.read( 1) * 10;
     unsigned minute  = memory::cartrtc.read( 2) + memory::cartrtc.read( 3) * 10;
     unsigned hour    = memory::cartrtc.read( 4) + memory::cartrtc.read( 5) * 10;
@@ -114,9 +128,9 @@ void SPC7110::update_time(int offset) {
 
     day--;
     month--;
-    year += (year >= 90) ? 1900 : 2000; //range = 1990-2089
+    year += (year >= 90) ? 1900 : 2000;  //range = 1990-2089
 
-    second += (unsigned)(current_time - rtc_time);
+    second += diff;
     while(second >= 60) {
       second -= 60;
 
@@ -168,13 +182,13 @@ void SPC7110::update_time(int offset) {
     memory::cartrtc.write(12, weekday % 7);
   }
 
-  memory::cartrtc.write(16, current_time);
-  memory::cartrtc.write(17, current_time >> 8);
+  memory::cartrtc.write(16, current_time >>  0);
+  memory::cartrtc.write(17, current_time >>  8);
   memory::cartrtc.write(18, current_time >> 16);
   memory::cartrtc.write(19, current_time >> 24);
 }
 
-uint8 SPC7110::mmio_read(uint addr) {
+uint8 SPC7110::mmio_read(unsigned addr) {
   addr &= 0xffff;
 
   switch(addr) {
@@ -215,7 +229,7 @@ uint8 SPC7110::mmio_read(uint addr) {
 
       unsigned addr = data_pointer();
       unsigned adjust = data_adjust();
-      if(r4818 & 8) adjust = (int16)adjust; //16-bit sign extend
+      if(r4818 & 8) adjust = (int16)adjust;  //16-bit sign extend
 
       unsigned adjustaddr = addr;
       if(r4818 & 2) {
@@ -226,7 +240,7 @@ uint8 SPC7110::mmio_read(uint addr) {
       uint8 data = memory::cartrom.read(datarom_addr(adjustaddr));
       if(!(r4818 & 2)) {
         unsigned increment = (r4818 & 1) ? data_increment() : 1;
-        if(r4818 & 4) increment = (int16)increment; //16-bit sign extend
+        if(r4818 & 4) increment = (int16)increment;  //16-bit sign extend
 
         if((r4818 & 16) == 0) {
           set_data_pointer(addr + increment);
@@ -250,7 +264,7 @@ uint8 SPC7110::mmio_read(uint addr) {
 
       unsigned addr = data_pointer();
       unsigned adjust = data_adjust();
-      if(r4818 & 8) adjust = (int16)adjust; //16-bit sign extend
+      if(r4818 & 8) adjust = (int16)adjust;  //16-bit sign extend
 
       uint8 data = memory::cartrom.read(datarom_addr(addr + adjust));
       if((r4818 & 0x60) == 0x60) {
@@ -322,7 +336,7 @@ uint8 SPC7110::mmio_read(uint addr) {
   return cpu.regs.mdr;
 }
 
-void SPC7110::mmio_write(uint addr, uint8 data) {
+void SPC7110::mmio_write(unsigned addr, uint8 data) {
   addr &= 0xffff;
 
   switch(addr) {
@@ -373,11 +387,11 @@ void SPC7110::mmio_write(uint addr, uint8 data) {
 
       if((r4818 & 0x60) == 0x20) {
         unsigned increment = data_adjust() & 0xff;
-        if(r4818 & 8) increment = (int8)increment; //8-bit sign extend
+        if(r4818 & 8) increment = (int8)increment;  //8-bit sign extend
         set_data_pointer(data_pointer() + increment);
       } else if((r4818 & 0x60) == 0x40) {
         unsigned increment = data_adjust();
-        if(r4818 & 8) increment = (int16)increment; //16-bit sign extend
+        if(r4818 & 8) increment = (int16)increment;  //16-bit sign extend
         set_data_pointer(data_pointer() + increment);
       }
     } break;
@@ -390,11 +404,11 @@ void SPC7110::mmio_write(uint addr, uint8 data) {
 
       if((r4818 & 0x60) == 0x20) {
         unsigned increment = data_adjust() & 0xff;
-        if(r4818 & 8) increment = (int8)increment; //8-bit sign extend
+        if(r4818 & 8) increment = (int8)increment;  //8-bit sign extend
         set_data_pointer(data_pointer() + increment);
       } else if((r4818 & 0x60) == 0x40) {
         unsigned increment = data_adjust();
-        if(r4818 & 8) increment = (int16)increment; //16-bit sign extend
+        if(r4818 & 8) increment = (int16)increment;  //16-bit sign extend
         set_data_pointer(data_pointer() + increment);
       }
     } break;
@@ -615,7 +629,7 @@ void SPC7110::mmio_write(uint addr, uint8 data) {
   }
 }
 
-uint8 SPC7110::read(uint addr) {
+uint8 SPC7110::read(unsigned addr) {
   //$[00-0f|80-8f]:[8000-ffff], $[c0-cf]:[0000-ffff] mapped directly to memory::cartrom
 
   if((addr & 0xffe000) == 0x006000 || (addr & 0xffe000) == 0x306000) {
@@ -646,7 +660,7 @@ uint8 SPC7110::read(uint addr) {
   return cpu.regs.mdr;
 }
 
-void SPC7110::write(uint addr, uint8 data) {
+void SPC7110::write(unsigned addr, uint8 data) {
   if((addr & 0xffe000) == 0x006000 || (addr & 0xffe000) == 0x306000) {
     //$[00|30]:[6000-7fff]
     if(r4830 & 0x80) memory::cartram.write(addr & 0x1fff, data);

src/chip/spc7110/spc7110.hpp

@@ -35,11 +35,11 @@ public:
   void update_time(int offset = 0);
   time_t create_time();
 
-  uint8 mmio_read (uint addr);
-  void  mmio_write(uint addr, uint8 data);
+  uint8 mmio_read (unsigned addr);
+  void  mmio_write(unsigned addr, uint8 data);
 
-  uint8 read (uint addr);
-  void  write(uint addr, uint8 data);
+  uint8 read (unsigned addr);
+  void  write(unsigned addr, uint8 data);
 
   //spc7110decomp
   void decomp_init();

src/chip/srtc/srtc.cpp

@@ -1,4 +1,6 @@
 #include <../base.hpp>
+#include <../cart/cart.hpp>
+#include "srtc.hpp"
 
 const unsigned SRTC::months[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
@@ -21,14 +23,26 @@ void SRTC::reset() {
 }
 
 void SRTC::update_time() {
-  time_t rtc_time;
-  rtc_time  = memory::cartrtc.read(16);
-  rtc_time |= memory::cartrtc.read(17) << 8;
-  rtc_time |= memory::cartrtc.read(18) << 16;
-  rtc_time |= memory::cartrtc.read(19) << 24;
-
+  time_t rtc_time
+  = (memory::cartrtc.read(16) <<  0)
+  | (memory::cartrtc.read(17) <<  8)
+  | (memory::cartrtc.read(18) << 16)
+  | (memory::cartrtc.read(19) << 24);
   time_t current_time = time(0);
-  if(current_time > rtc_time) {
+
+  //sizeof(time_t) is platform-dependent; though memory::cartrtc needs to be platform-agnostic.
+  //yet platforms with 32-bit signed time_t will overflow every ~68 years. handle this by
+  //accounting for overflow at the cost of 1-bit precision (to catch underflow). this will allow
+  //memory::cartrtc timestamp to remain valid for up to ~34 years from the last update, even if
+  //time_t overflows. calculation should be valid regardless of number representation, time_t size,
+  //or whether time_t is signed or unsigned.
+  time_t diff
+  = (current_time >= rtc_time)
+  ? (current_time - rtc_time)
+  : (std::numeric_limits<time_t>::max() - rtc_time + current_time + 1);  //compensate for overflow
+  if(diff > std::numeric_limits<time_t>::max() / 2) diff = 0;            //compensate for underflow
+
+  if(diff > 0) {
     unsigned second  = memory::cartrtc.read( 0) + memory::cartrtc.read( 1) * 10;
     unsigned minute  = memory::cartrtc.read( 2) + memory::cartrtc.read( 3) * 10;
     unsigned hour    = memory::cartrtc.read( 4) + memory::cartrtc.read( 5) * 10;
@@ -41,8 +55,7 @@ void SRTC::update_time() {
     month--;
     year += 1000;
 
-    second += (unsigned)(current_time - rtc_time);
-
+    second += diff;
     while(second >= 60) {
       second -= 60;
 
@@ -94,8 +107,8 @@ void SRTC::update_time() {
     memory::cartrtc.write(12, weekday % 7);
   }
 
-  memory::cartrtc.write(16, current_time);
-  memory::cartrtc.write(17, current_time >> 8);
+  memory::cartrtc.write(16, current_time >>  0);
+  memory::cartrtc.write(17, current_time >>  8);
   memory::cartrtc.write(18, current_time >> 16);
   memory::cartrtc.write(19, current_time >> 24);
 }
@@ -104,8 +117,8 @@ void SRTC::update_time() {
 //eg 0 = Sunday, 1 = Monday, ... 6 = Saturday
 //usage: weekday(2008, 1, 1) returns weekday of January 1st, 2008
 unsigned SRTC::weekday(unsigned year, unsigned month, unsigned day) {
-  unsigned y = 1900, m = 1; //epoch is 1900-01-01
-  unsigned sum = 0; //number of days passed since epoch
+  unsigned y = 1900, m = 1;  //epoch is 1900-01-01
+  unsigned sum = 0;          //number of days passed since epoch
 
   year = max(1900, year);
   month = max(1, min(12, month));
@@ -136,7 +149,7 @@ unsigned SRTC::weekday(unsigned year, unsigned month, unsigned day) {
   }
 
   sum += day - 1;
-  return (sum + 1) % 7; //1900-01-01 was a Monday
+  return (sum + 1) % 7;  //1900-01-01 was a Monday
 }
 
 uint8 SRTC::mmio_read(unsigned addr) {
@@ -164,7 +177,7 @@ void SRTC::mmio_write(unsigned addr, uint8 data) {
   addr &= 0xffff;
 
   if(addr == 0x2801) {
-    data &= 0x0f; //only the low four bits are used
+    data &= 0x0f;  //only the low four bits are used
 
     if(data == 0x0d) {
       rtc_mode = RTCM_Read;
@@ -177,7 +190,7 @@ void SRTC::mmio_write(unsigned addr, uint8 data) {
       return;
     }
 
-    if(data == 0x0f) return; //unknown behavior
+    if(data == 0x0f) return;  //unknown behavior
 
     if(rtc_mode == RTCM_Write) {
       if(rtc_index >= 0 && rtc_index < 12) {

src/chip/st010/st010.cpp

@@ -1,6 +1,7 @@
 #include <../base.hpp>
 #define ST010_CPP
 
+#include "st010.hpp"
 #include "st010_data.hpp"
 #include "st010_op.cpp"
 
@@ -62,11 +63,11 @@ void ST010::reset() {
 
 //
 
-uint8 ST010::read(uint addr) {
+uint8 ST010::read(unsigned addr) {
   return readb(addr);
 }
 
-void ST010::write(uint addr, uint8 data) {
+void ST010::write(unsigned addr, uint8 data) {
   writeb(addr, data);
 
   if((addr & 0xfff) == 0x0021 && (data & 0x80)) {

src/chip/st010/st010.hpp

@@ -5,8 +5,8 @@ public:
   void power();
   void reset();
 
-  uint8 read (uint addr);
-  void  write(uint addr, uint8 data);
+  uint8 read (unsigned addr);
+  void  write(unsigned addr, uint8 data);
 
 private:
   uint8 ram[0x1000];

src/chip/st010/st010_op.cpp

@@ -258,4 +258,4 @@ int16 x1, y1;
   writew(0x0012, y1);
 }
 
-#endif //ifdef ST010_CPP
+#endif

src/clean.bat

@@ -1 +1 @@
-@make platform=win compiler=mingw32-gcc clean
+@mingw32-make platform=win compiler=mingw32-gcc clean

src/config/config.cpp

@@ -1,105 +0,0 @@
-#include <../base.hpp>
-
-namespace config {
-
-configuration& config() {
-  static configuration config;
-  return config;
-}
-
-string filepath(const char *filename, const char *pathname) {
-  //if no pathname, return filename as-is
-  string file(filename);
-  replace(file, "\\", "/");
-  if(!pathname || !*pathname) return file;
-
-  //ensure path ends with trailing '/'
-  string path(pathname);
-  replace(path, "\\", "/");
-  if(!strend(path, "/")) strcat(path, "/");
-
-  //replace relative path with absolute path
-  if(strbegin(path, "./")) {
-    ltrim(path, "./");
-    path = string() << config::path.base << path;
-  }
-
-  //remove folder part of filename
-  lstring part;
-  split(part, "/", file);
-  return path << part[count(part) - 1];
-}
-
-integral_setting File::autodetect_type(config(), "file.autodetect_type",
-  "Auto-detect file type by inspecting file header, rather than by file extension.\n"
-  "In other words, if a .zip file is renamed to .smc, it will still be correctly "
-  "identified as a .zip file. However, there is an infinitesimal (1:~500,000,000) "
-  "chance of a false detection when loading an uncompressed image file, if this "
-  "option is enabled.",
-  integral_setting::boolean, false);
-
-integral_setting File::bypass_patch_crc32(config(), "file.bypass_patch_crc32",
-  "UPS patches contain CRC32s to validate that a patch was applied successfully.\n"
-  "By default, if this validation fails, said patch will not be applied. "
-  "Setting this option to true will bypass the validation, "
-  "which may or may not result in a working image. "
-  "Thus, enabling this option is strongly discouraged.",
-  integral_setting::boolean, false);
-
-string_setting Path::base("path.base", "Path that bsnes resides in", "");
-string_setting Path::user("path.user", "Path to user folder", "");
-
-string_setting Path::rom(config(), "path.rom",
-  "Default path to look for ROM files in (\"\" = use default directory)", "");
-string_setting Path::save(config(), "path.save",
-  "Default path for all save RAM files (\"\" = use current directory)", "");
-string_setting Path::patch(config(), "path.patch",
-  "Default path for all UPS patch files (\"\" = use current directory)", "");
-string_setting Path::cheat(config(), "path.cheat",
-  "Default path for all cheat files (\"\" = use current directory)", "");
-string_setting Path::exportdata(config(), "path.export",
-  "Default path for all exported data files\n", "");
-
-string_setting Path::bsx(config(), "path.bsx", "", "");
-string_setting Path::st(config(), "path.st", "", "");
-
-integral_setting SNES::controller_port1(config(), "snes.controller_port1",
-  "Controller attached to SNES port 1", integral_setting::decimal, ::SNES::Input::DeviceJoypad);
-integral_setting SNES::controller_port2(config(), "snes.controller_port2",
-  "Controller attached to SNES port 2", integral_setting::decimal, ::SNES::Input::DeviceJoypad);
-integral_setting SNES::expansion_port(config(), "snes.expansion_port",
-  "Device attached to SNES expansion port\n"
-  "0 = None\n"
-  "1 = Satellaview BS-X",
-  integral_setting::decimal, ::SNES::ExpansionBSX);
-integral_setting SNES::region(config(), "snes.region",
-  "SNES regional model\n"
-  "0 = Auto-detect based on cartridge\n"
-  "1 = NTSC\n"
-  "2 = PAL",
-  integral_setting::decimal, ::SNES::Autodetect);
-
-integral_setting CPU::ntsc_clock_rate(config(), "cpu.ntsc_clock_rate",
-  "NTSC S-CPU clock rate (in hz)", integral_setting::decimal, 21477272);
-integral_setting CPU::pal_clock_rate(config(), "cpu.pal_clock_rate",
-  "PAL S-CPU clock rate (in hz)", integral_setting::decimal,  21281370);
-integral_setting CPU::wram_init_value(config(), "cpu.wram_init_value",
-  "Value to initialize 128k WRAM to upon power cycle.\n"
-  "Note that on real hardware, this value is undefined; meaning it can vary "
-  "per power-on, and per SNES unit. Such randomness is undesirable for an "
-  "emulator, so a static value is needed. There is also some form of pattern "
-  "to the randomness that has yet to be determined, which some games rely upon.\n"
-  "A value of 0x55 is safe for all known commercial software, and should be used. "
-  "However, some software written for SNES copiers, or backup units, relies on "
-  "WRAM being initialized to 0x00; which was a side-effect of the BIOS program "
-  "which executed on these copiers. Using 0x00 will therefore fix many homebrew "
-  "programs, but *will* break some poorly programmed commercial software titles, "
-  "which do not properly initialize WRAM upon power cycle.",
-  integral_setting::hex, 0x55);
-
-integral_setting SMP::ntsc_clock_rate(config(), "smp.ntsc_clock_rate",
-  "NTSC S-SMP clock rate (in hz)", integral_setting::decimal, 32041 * 768);
-integral_setting SMP::pal_clock_rate(config(), "smp.pal_clock_rate",
-  "PAL S-SMP clock rate (in hz)", integral_setting::decimal,  32041 * 768);
-
-} //namespace config

src/config/config.hpp

@@ -1,34 +0,0 @@
-namespace config {
-
-extern configuration& config();
-
-string filepath(const char *filename, const char *pathname);
-
-extern struct File {
-  static integral_setting autodetect_type;
-  static integral_setting bypass_patch_crc32;
-} file;
-
-extern struct Path {
-  static string_setting base, user;
-  static string_setting rom, save, patch, cheat, exportdata;
-  static string_setting bsx, st;
-} path;
-
-extern struct SNES {
-  static integral_setting controller_port1;
-  static integral_setting controller_port2;
-  static integral_setting expansion_port;
-  static integral_setting region;
-} snes;
-
-extern struct CPU {
-  static integral_setting ntsc_clock_rate, pal_clock_rate;
-  static integral_setting wram_init_value;
-} cpu;
-
-extern struct SMP {
-  static integral_setting ntsc_clock_rate, pal_clock_rate;
-} smp;
-
-};

src/cpu/cpu.cpp

@@ -3,8 +3,14 @@
 
 #include "dcpu.cpp"
 
+void CPU::power() {
+  cpu_version = snes.config.cpu.version;
+}
+
+void CPU::reset() {
+}
+
 CPU::CPU() {
-  cpu_version = 2;
 }
 
 CPU::~CPU() {

src/cpu/cpu.hpp

@@ -17,9 +17,8 @@ public:
   regs_t regs;
 
   virtual void scanline() = 0;
-  virtual void frame() = 0;
-  virtual void power() = 0;
-  virtual void reset() = 0;
+  virtual void power();
+  virtual void reset();
 
   /*****
    * in opcode-based CPU emulators, the main emulation routine

src/cpu/dcpu.cpp

@@ -2,22 +2,22 @@
 
 uint8  CPU::dreadb(uint32 addr) {
   if((addr & 0x40ffff) >= 0x2000 && (addr & 0x40ffff) <= 0x5fff) {
-  //$[00-3f|80-bf]:[2000-5fff]
-  //do not read MMIO registers within debugger
+    //$[00-3f|80-bf]:[2000-5fff]
+    //do not read MMIO registers within debugger
     return 0x00;
   }
   return bus.read(addr);
 }
 
 uint16 CPU::dreadw(uint32 addr) {
-uint16 r;
+  uint16 r;
   r  = dreadb((addr + 0) & 0xffffff) <<  0;
   r |= dreadb((addr + 1) & 0xffffff) <<  8;
   return r;
 }
 
 uint32 CPU::dreadl(uint32 addr) {
-uint32 r;
+  uint32 r;
   r  = dreadb((addr + 0) & 0xffffff) <<  0;
   r |= dreadb((addr + 1) & 0xffffff) <<  8;
   r |= dreadb((addr + 2) & 0xffffff) << 16;
@@ -25,87 +25,89 @@ uint32 r;
 }
 
 uint32 CPU::decode(uint8 offset_type, uint32 addr) {
-uint32 r = 0;
+  uint32 r = 0;
+
   switch(offset_type) {
-  case OPTYPE_DP:
-    r = (regs.d + (addr & 0xffff)) & 0xffff;
-    break;
-  case OPTYPE_DPX:
-    r = (regs.d + regs.x + (addr & 0xffff)) & 0xffff;
-    break;
-  case OPTYPE_DPY:
-    r = (regs.d + regs.y + (addr & 0xffff)) & 0xffff;
-    break;
-  case OPTYPE_IDP:
-    addr = (regs.d + (addr & 0xffff)) & 0xffff;
-    r = (regs.db << 16) + dreadw(addr);
-    break;
-  case OPTYPE_IDPX:
-    addr = (regs.d + regs.x + (addr & 0xffff)) & 0xffff;
-    r = (regs.db << 16) + dreadw(addr);
-    break;
-  case OPTYPE_IDPY:
-    addr = (regs.d + (addr & 0xffff)) & 0xffff;
-    r = (regs.db << 16) + dreadw(addr) + regs.y;
-    break;
-  case OPTYPE_ILDP:
-    addr = (regs.d + (addr & 0xffff)) & 0xffff;
-    r = dreadl(addr);
-    break;
-  case OPTYPE_ILDPY:
-    addr = (regs.d + (addr & 0xffff)) & 0xffff;
-    r = dreadl(addr) + regs.y;
-    break;
-  case OPTYPE_ADDR:
-    r = (regs.db << 16) + (addr & 0xffff);
-    break;
-  case OPTYPE_ADDR_PC:
-    r = (regs.pc.b << 16) + (addr & 0xffff);
-    break;
-  case OPTYPE_ADDRX:
-    r = (regs.db << 16) + (addr & 0xffff) + regs.x;
-    break;
-  case OPTYPE_ADDRY:
-    r = (regs.db << 16) + (addr & 0xffff) + regs.y;
-    break;
-  case OPTYPE_IADDR_PC:
-    r = (regs.pc.b << 16) + (addr & 0xffff);
-    break;
-  case OPTYPE_IADDRX:
-    r = (regs.pc.b << 16) + ((addr + regs.x) & 0xffff);
-    break;
-  case OPTYPE_ILADDR:
-    r = addr;
-    break;
-  case OPTYPE_LONG:
-    r = addr;
-    break;
-  case OPTYPE_LONGX:
-    r = (addr + regs.x);
-    break;
-  case OPTYPE_SR:
-    r = (regs.s + (addr & 0xff)) & 0xffff;
-    break;
-  case OPTYPE_ISRY:
-    addr = (regs.s + (addr & 0xff)) & 0xffff;
-    r = (regs.db << 16) + dreadw(addr) + regs.y;
-    break;
-  case OPTYPE_RELB:
-    r  = (regs.pc.b << 16) + ((regs.pc.w + 2) & 0xffff);
-    r += int8(addr);
-    break;
-  case OPTYPE_RELW:
-    r  = (regs.pc.b << 16) + ((regs.pc.w + 3) & 0xffff);
-    r += int16(addr);
-    break;
+    case OPTYPE_DP:
+      r = (regs.d + (addr & 0xffff)) & 0xffff;
+      break;
+    case OPTYPE_DPX:
+      r = (regs.d + regs.x + (addr & 0xffff)) & 0xffff;
+      break;
+    case OPTYPE_DPY:
+      r = (regs.d + regs.y + (addr & 0xffff)) & 0xffff;
+      break;
+    case OPTYPE_IDP:
+      addr = (regs.d + (addr & 0xffff)) & 0xffff;
+      r = (regs.db << 16) + dreadw(addr);
+      break;
+    case OPTYPE_IDPX:
+      addr = (regs.d + regs.x + (addr & 0xffff)) & 0xffff;
+      r = (regs.db << 16) + dreadw(addr);
+      break;
+    case OPTYPE_IDPY:
+      addr = (regs.d + (addr & 0xffff)) & 0xffff;
+      r = (regs.db << 16) + dreadw(addr) + regs.y;
+      break;
+    case OPTYPE_ILDP:
+      addr = (regs.d + (addr & 0xffff)) & 0xffff;
+      r = dreadl(addr);
+      break;
+    case OPTYPE_ILDPY:
+      addr = (regs.d + (addr & 0xffff)) & 0xffff;
+      r = dreadl(addr) + regs.y;
+      break;
+    case OPTYPE_ADDR:
+      r = (regs.db << 16) + (addr & 0xffff);
+      break;
+    case OPTYPE_ADDR_PC:
+      r = (regs.pc.b << 16) + (addr & 0xffff);
+      break;
+    case OPTYPE_ADDRX:
+      r = (regs.db << 16) + (addr & 0xffff) + regs.x;
+      break;
+    case OPTYPE_ADDRY:
+      r = (regs.db << 16) + (addr & 0xffff) + regs.y;
+      break;
+    case OPTYPE_IADDR_PC:
+      r = (regs.pc.b << 16) + (addr & 0xffff);
+      break;
+    case OPTYPE_IADDRX:
+      r = (regs.pc.b << 16) + ((addr + regs.x) & 0xffff);
+      break;
+    case OPTYPE_ILADDR:
+      r = addr;
+      break;
+    case OPTYPE_LONG:
+      r = addr;
+      break;
+    case OPTYPE_LONGX:
+      r = (addr + regs.x);
+      break;
+    case OPTYPE_SR:
+      r = (regs.s + (addr & 0xff)) & 0xffff;
+      break;
+    case OPTYPE_ISRY:
+      addr = (regs.s + (addr & 0xff)) & 0xffff;
+      r = (regs.db << 16) + dreadw(addr) + regs.y;
+      break;
+    case OPTYPE_RELB:
+      r  = (regs.pc.b << 16) + ((regs.pc.w + 2) & 0xffff);
+      r += int8(addr);
+      break;
+    case OPTYPE_RELW:
+      r  = (regs.pc.b << 16) + ((regs.pc.w + 3) & 0xffff);
+      r += int16(addr);
+      break;
   }
+
   return(r & 0xffffff);
 }
 
 void CPU::disassemble_opcode(char *output) {
-static reg24_t pc;
-char t[256];
-char *s = output;
+  static reg24_t pc;
+  char t[256];
+  char *s = output;
 
   if(in_opcode() == true) {
     strcpy(s, "?????? <CPU within opcode>");
@@ -113,367 +115,369 @@ char *s = output;
   }
 
   pc.d = regs.pc.d;
-  sprintf(s, "%0.6x ", uint32(pc.d));
+  sprintf(s, "%.6x ", (uint32)pc.d);
 
-uint8 op  = dreadb(pc.d); pc.w++;
-uint8 op0 = dreadb(pc.d); pc.w++;
-uint8 op1 = dreadb(pc.d); pc.w++;
-uint8 op2 = dreadb(pc.d);
+  uint8 op  = dreadb(pc.d); pc.w++;
+  uint8 op0 = dreadb(pc.d); pc.w++;
+  uint8 op1 = dreadb(pc.d); pc.w++;
+  uint8 op2 = dreadb(pc.d);
+
+  #define op8  ((op0))
+  #define op16 ((op0) | (op1 << 8))
+  #define op24 ((op0) | (op1 << 8) | (op2 << 16))
+  #define a8   (regs.e || regs.p.m)
+  #define x8   (regs.e || regs.p.x)
 
-#define op8  ((op0))
-#define op16 ((op0) | (op1 << 8))
-#define op24 ((op0) | (op1 << 8) | (op2 << 16))
-#define a8   (regs.e || regs.p.m)
-#define x8   (regs.e || regs.p.x)
   switch(op) {
-  case 0x00: sprintf(t, "brk #$%0.2x               ", op8); break;
-  case 0x01: sprintf(t, "ora ($%0.2x,x)   [$%0.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
-  case 0x02: sprintf(t, "cop #$%0.2x               ", op8); break;
-  case 0x03: sprintf(t, "ora $%0.2x,s     [$%0.6x]", op8, decode(OPTYPE_SR, op8)); break;
-  case 0x04: sprintf(t, "tsb $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x05: sprintf(t, "ora $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x06: sprintf(t, "asl $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x07: sprintf(t, "ora [$%0.2x]     [$%0.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
-  case 0x08: sprintf(t, "php                    "); break;
-  case 0x09: if(a8)sprintf(t, "ora #$%0.2x               ", op8);
-             else  sprintf(t, "ora #$%0.4x             ", op16); break;
-  case 0x0a: sprintf(t, "asl a                  "); break;
-  case 0x0b: sprintf(t, "phd                    "); break;
-  case 0x0c: sprintf(t, "tsb $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x0d: sprintf(t, "ora $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x0e: sprintf(t, "asl $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x0f: sprintf(t, "ora $%0.6x   [$%0.6x]", op24, decode(OPTYPE_LONG, op24)); break;
-  case 0x10: sprintf(t, "bpl $%0.4x     [$%0.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
-  case 0x11: sprintf(t, "ora ($%0.2x),y   [$%0.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
-  case 0x12: sprintf(t, "ora ($%0.2x)     [$%0.6x]", op8, decode(OPTYPE_IDP, op8)); break;
-  case 0x13: sprintf(t, "ora ($%0.2x,s),y [$%0.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
-  case 0x14: sprintf(t, "trb $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x15: sprintf(t, "ora $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x16: sprintf(t, "asl $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x17: sprintf(t, "ora [$%0.2x],y   [$%0.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
-  case 0x18: sprintf(t, "clc                    "); break;
-  case 0x19: sprintf(t, "ora $%0.4x,y   [$%0.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
-  case 0x1a: sprintf(t, "inc                    "); break;
-  case 0x1b: sprintf(t, "tcs                    "); break;
-  case 0x1c: sprintf(t, "trb $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x1d: sprintf(t, "ora $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0x1e: sprintf(t, "asl $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0x1f: sprintf(t, "ora $%0.6x,x [$%0.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
-  case 0x20: sprintf(t, "jsr $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR_PC, op16)); break;
-  case 0x21: sprintf(t, "and ($%0.2x,x)   [$%0.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
-  case 0x22: sprintf(t, "jsl $%0.6x   [$%0.6x]", op24, decode(OPTYPE_LONG, op24)); break;
-  case 0x23: sprintf(t, "and $%0.2x,s     [$%0.6x]", op8, decode(OPTYPE_SR, op8)); break;
-  case 0x24: sprintf(t, "bit $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x25: sprintf(t, "and $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x26: sprintf(t, "rol $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x27: sprintf(t, "and [$%0.2x]     [$%0.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
-  case 0x28: sprintf(t, "plp                    "); break;
-  case 0x29: if(a8)sprintf(t, "and #$%0.2x               ", op8);
-             else  sprintf(t, "and #$%0.4x             ", op16); break;
-  case 0x2a: sprintf(t, "rol a                  "); break;
-  case 0x2b: sprintf(t, "pld                    "); break;
-  case 0x2c: sprintf(t, "bit $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x2d: sprintf(t, "and $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x2e: sprintf(t, "rol $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x2f: sprintf(t, "and $%0.6x   [$%0.6x]", op24, decode(OPTYPE_LONG, op24)); break;
-  case 0x30: sprintf(t, "bmi $%0.4x     [$%0.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
-  case 0x31: sprintf(t, "and ($%0.2x),y   [$%0.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
-  case 0x32: sprintf(t, "and ($%0.2x)     [$%0.6x]", op8, decode(OPTYPE_IDP, op8)); break;
-  case 0x33: sprintf(t, "and ($%0.2x,s),y [$%0.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
-  case 0x34: sprintf(t, "bit $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x35: sprintf(t, "and $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x36: sprintf(t, "rol $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x37: sprintf(t, "and [$%0.2x],y   [$%0.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
-  case 0x38: sprintf(t, "sec                    "); break;
-  case 0x39: sprintf(t, "and $%0.4x,y   [$%0.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
-  case 0x3a: sprintf(t, "dec                    "); break;
-  case 0x3b: sprintf(t, "tsc                    "); break;
-  case 0x3c: sprintf(t, "bit $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0x3d: sprintf(t, "and $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0x3e: sprintf(t, "rol $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0x3f: sprintf(t, "and $%0.6x,x [$%0.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
-  case 0x40: sprintf(t, "rti                    "); break;
-  case 0x41: sprintf(t, "eor ($%0.2x,x)   [$%0.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
-  case 0x42: sprintf(t, "wdm                    "); break;
-  case 0x43: sprintf(t, "eor $%0.2x,s     [$%0.6x]", op8, decode(OPTYPE_SR, op8)); break;
-  case 0x44: sprintf(t, "mvp $%0.2x,$%0.2x            ", op1, op8); break;
-  case 0x45: sprintf(t, "eor $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x46: sprintf(t, "lsr $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x47: sprintf(t, "eor [$%0.2x]     [$%0.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
-  case 0x48: sprintf(t, "pha                    "); break;
-  case 0x49: if(a8)sprintf(t, "eor #$%0.2x               ", op8);
-             else  sprintf(t, "eor #$%0.4x             ", op16); break;
-  case 0x4a: sprintf(t, "lsr a                  "); break;
-  case 0x4b: sprintf(t, "phk                    "); break;
-  case 0x4c: sprintf(t, "jmp $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR_PC, op16)); break;
-  case 0x4d: sprintf(t, "eor $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x4e: sprintf(t, "lsr $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x4f: sprintf(t, "eor $%0.6x   [$%0.6x]", op24, decode(OPTYPE_LONG, op24)); break;
-  case 0x50: sprintf(t, "bvc $%0.4x     [$%0.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
-  case 0x51: sprintf(t, "eor ($%0.2x),y   [$%0.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
-  case 0x52: sprintf(t, "eor ($%0.2x)     [$%0.6x]", op8, decode(OPTYPE_IDP, op8)); break;
-  case 0x53: sprintf(t, "eor ($%0.2x,s),y [$%0.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
-  case 0x54: sprintf(t, "mvn $%0.2x,$%0.2x            ", op1, op8); break;
-  case 0x55: sprintf(t, "eor $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x56: sprintf(t, "lsr $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x57: sprintf(t, "eor [$%0.2x],y   [$%0.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
-  case 0x58: sprintf(t, "cli                    "); break;
-  case 0x59: sprintf(t, "eor $%0.4x,y   [$%0.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
-  case 0x5a: sprintf(t, "phy                    "); break;
-  case 0x5b: sprintf(t, "tcd                    "); break;
-  case 0x5c: sprintf(t, "jml $%0.6x   [$%0.6x]", op24, decode(OPTYPE_LONG, op24)); break;
-  case 0x5d: sprintf(t, "eor $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0x5e: sprintf(t, "lsr $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0x5f: sprintf(t, "eor $%0.6x,x [$%0.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
-  case 0x60: sprintf(t, "rts                    "); break;
-  case 0x61: sprintf(t, "adc ($%0.2x,x)   [$%0.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
-  case 0x62: sprintf(t, "per $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x63: sprintf(t, "adc $%0.2x,s     [$%0.6x]", op8, decode(OPTYPE_SR, op8)); break;
-  case 0x64: sprintf(t, "stz $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x65: sprintf(t, "adc $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x66: sprintf(t, "ror $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x67: sprintf(t, "adc [$%0.2x]     [$%0.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
-  case 0x68: sprintf(t, "pla                    "); break;
-  case 0x69: if(a8)sprintf(t, "adc #$%0.2x               ", op8);
-             else  sprintf(t, "adc #$%0.4x             ", op16); break;
-  case 0x6a: sprintf(t, "ror a                  "); break;
-  case 0x6b: sprintf(t, "rtl                    "); break;
-  case 0x6c: sprintf(t, "jmp ($%0.4x)   [$%0.6x]", op16, decode(OPTYPE_IADDR_PC, op16)); break;
-  case 0x6d: sprintf(t, "adc $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x6e: sprintf(t, "ror $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x6f: sprintf(t, "adc $%0.6x   [$%0.6x]", op24, decode(OPTYPE_LONG, op24)); break;
-  case 0x70: sprintf(t, "bvs $%0.4x     [$%0.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
-  case 0x71: sprintf(t, "adc ($%0.2x),y   [$%0.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
-  case 0x72: sprintf(t, "adc ($%0.2x)     [$%0.6x]", op8, decode(OPTYPE_IDP, op8)); break;
-  case 0x73: sprintf(t, "adc ($%0.2x,s),y [$%0.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
-  case 0x74: sprintf(t, "stz $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x75: sprintf(t, "adc $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x76: sprintf(t, "ror $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x77: sprintf(t, "adc [$%0.2x],y   [$%0.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
-  case 0x78: sprintf(t, "sei                    "); break;
-  case 0x79: sprintf(t, "adc $%0.4x,y   [$%0.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
-  case 0x7a: sprintf(t, "ply                    "); break;
-  case 0x7b: sprintf(t, "tdc                    "); break;
-  case 0x7c: sprintf(t, "jmp ($%0.4x,x) [$%0.6x]", op16, decode(OPTYPE_IADDRX, op16)); break;
-  case 0x7d: sprintf(t, "adc $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0x7e: sprintf(t, "ror $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0x7f: sprintf(t, "adc $%0.6x,x [$%0.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
-  case 0x80: sprintf(t, "bra $%0.4x     [$%0.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
-  case 0x81: sprintf(t, "sta ($%0.2x,x)   [$%0.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
-  case 0x82: sprintf(t, "brl $%0.4x     [$%0.6x]", uint16(decode(OPTYPE_RELW, op16)), decode(OPTYPE_RELW, op16)); break;
-  case 0x83: sprintf(t, "sta $%0.2x,s     [$%0.6x]", op8, decode(OPTYPE_SR, op8)); break;
-  case 0x84: sprintf(t, "sty $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x85: sprintf(t, "sta $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x86: sprintf(t, "stx $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0x87: sprintf(t, "sta [$%0.2x]     [$%0.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
-  case 0x88: sprintf(t, "dey                    "); break;
-  case 0x89: if(a8)sprintf(t, "bit #$%0.2x               ", op8);
-             else  sprintf(t, "bit #$%0.4x             ", op16); break;
-  case 0x8a: sprintf(t, "txa                    "); break;
-  case 0x8b: sprintf(t, "phb                    "); break;
-  case 0x8c: sprintf(t, "sty $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x8d: sprintf(t, "sta $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x8e: sprintf(t, "stx $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x8f: sprintf(t, "sta $%0.6x   [$%0.6x]", op24, decode(OPTYPE_LONG, op24)); break;
-  case 0x90: sprintf(t, "bcc $%0.4x     [$%0.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
-  case 0x91: sprintf(t, "sta ($%0.2x),y   [$%0.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
-  case 0x92: sprintf(t, "sta ($%0.2x)     [$%0.6x]", op8, decode(OPTYPE_IDP, op8)); break;
-  case 0x93: sprintf(t, "sta ($%0.2x,s),y [$%0.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
-  case 0x94: sprintf(t, "sty $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x95: sprintf(t, "sta $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0x96: sprintf(t, "stx $%0.2x,y     [$%0.6x]", op8, decode(OPTYPE_DPY, op8)); break;
-  case 0x97: sprintf(t, "sta [$%0.2x],y   [$%0.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
-  case 0x98: sprintf(t, "tya                    "); break;
-  case 0x99: sprintf(t, "sta $%0.4x,y   [$%0.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
-  case 0x9a: sprintf(t, "txs                    "); break;
-  case 0x9b: sprintf(t, "txy                    "); break;
-  case 0x9c: sprintf(t, "stz $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0x9d: sprintf(t, "sta $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0x9e: sprintf(t, "stz $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0x9f: sprintf(t, "sta $%0.6x,x [$%0.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
-  case 0xa0: if(x8)sprintf(t, "ldy #$%0.2x               ", op8);
-             else  sprintf(t, "ldy #$%0.4x             ", op16); break;
-  case 0xa1: sprintf(t, "lda ($%0.2x,x)   [$%0.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
-  case 0xa2: if(x8)sprintf(t, "ldx #$%0.2x               ", op8);
-             else  sprintf(t, "ldx #$%0.4x             ", op16); break;
-  case 0xa3: sprintf(t, "lda $%0.2x,s     [$%0.6x]", op8, decode(OPTYPE_SR, op8)); break;
-  case 0xa4: sprintf(t, "ldy $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0xa5: sprintf(t, "lda $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0xa6: sprintf(t, "ldx $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0xa7: sprintf(t, "lda [$%0.2x]     [$%0.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
-  case 0xa8: sprintf(t, "tay                    "); break;
-  case 0xa9: if(a8)sprintf(t, "lda #$%0.2x               ", op8);
-             else  sprintf(t, "lda #$%0.4x             ", op16); break;
-  case 0xaa: sprintf(t, "tax                    "); break;
-  case 0xab: sprintf(t, "plb                    "); break;
-  case 0xac: sprintf(t, "ldy $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0xad: sprintf(t, "lda $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0xae: sprintf(t, "ldx $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0xaf: sprintf(t, "lda $%0.6x   [$%0.6x]", op24, decode(OPTYPE_LONG, op24)); break;
-  case 0xb0: sprintf(t, "bcs $%0.4x     [$%0.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
-  case 0xb1: sprintf(t, "lda ($%0.2x),y   [$%0.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
-  case 0xb2: sprintf(t, "lda ($%0.2x)     [$%0.6x]", op8, decode(OPTYPE_IDP, op8)); break;
-  case 0xb3: sprintf(t, "lda ($%0.2x,s),y [$%0.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
-  case 0xb4: sprintf(t, "ldy $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0xb5: sprintf(t, "lda $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0xb6: sprintf(t, "ldx $%0.2x,y     [$%0.6x]", op8, decode(OPTYPE_DPY, op8)); break;
-  case 0xb7: sprintf(t, "lda [$%0.2x],y   [$%0.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
-  case 0xb8: sprintf(t, "clv                    "); break;
-  case 0xb9: sprintf(t, "lda $%0.4x,y   [$%0.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
-  case 0xba: sprintf(t, "tsx                    "); break;
-  case 0xbb: sprintf(t, "tyx                    "); break;
-  case 0xbc: sprintf(t, "ldy $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0xbd: sprintf(t, "lda $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0xbe: sprintf(t, "ldx $%0.4x,y   [$%0.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
-  case 0xbf: sprintf(t, "lda $%0.6x,x [$%0.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
-  case 0xc0: if(x8)sprintf(t, "cpy #$%0.2x               ", op8);
-             else  sprintf(t, "cpy #$%0.4x             ", op16); break;
-  case 0xc1: sprintf(t, "cmp ($%0.2x,x)   [$%0.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
-  case 0xc2: sprintf(t, "rep #$%0.2x               ", op8); break;
-  case 0xc3: sprintf(t, "cmp $%0.2x,s     [$%0.6x]", op8, decode(OPTYPE_SR, op8)); break;
-  case 0xc4: sprintf(t, "cpy $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0xc5: sprintf(t, "cmp $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0xc6: sprintf(t, "dec $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0xc7: sprintf(t, "cmp [$%0.2x]     [$%0.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
-  case 0xc8: sprintf(t, "iny                    "); break;
-  case 0xc9: if(a8)sprintf(t, "cmp #$%0.2x               ", op8);
-             else  sprintf(t, "cmp #$%0.4x             ", op16); break;
-  case 0xca: sprintf(t, "dex                    "); break;
-  case 0xcb: sprintf(t, "wai                    "); break;
-  case 0xcc: sprintf(t, "cpy $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0xcd: sprintf(t, "cmp $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0xce: sprintf(t, "dec $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0xcf: sprintf(t, "cmp $%0.6x   [$%0.6x]", op24, decode(OPTYPE_LONG, op24)); break;
-  case 0xd0: sprintf(t, "bne $%0.4x     [$%0.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
-  case 0xd1: sprintf(t, "cmp ($%0.2x),y   [$%0.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
-  case 0xd2: sprintf(t, "cmp ($%0.2x)     [$%0.6x]", op8, decode(OPTYPE_IDP, op8)); break;
-  case 0xd3: sprintf(t, "cmp ($%0.2x,s),y [$%0.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
-  case 0xd4: sprintf(t, "pei ($%0.2x)     [$%0.6x]", op8, decode(OPTYPE_IDP, op8)); break;
-  case 0xd5: sprintf(t, "cmp $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0xd6: sprintf(t, "dec $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0xd7: sprintf(t, "cmp [$%0.2x],y   [$%0.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
-  case 0xd8: sprintf(t, "cld                    "); break;
-  case 0xd9: sprintf(t, "cmp $%0.4x,y   [$%0.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
-  case 0xda: sprintf(t, "phx                    "); break;
-  case 0xdb: sprintf(t, "stp                    "); break;
-  case 0xdc: sprintf(t, "jmp [$%0.4x]   [$%0.6x]", op16, decode(OPTYPE_ILADDR, op16)); break;
-  case 0xdd: sprintf(t, "cmp $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0xde: sprintf(t, "dec $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0xdf: sprintf(t, "cmp $%0.6x,x [$%0.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
-  case 0xe0: if(x8)sprintf(t, "cpx #$%0.2x               ", op8);
-             else  sprintf(t, "cpx #$%0.4x             ", op16); break;
-  case 0xe1: sprintf(t, "sbc ($%0.2x,x)   [$%0.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
-  case 0xe2: sprintf(t, "sep #$%0.2x               ", op8); break;
-  case 0xe3: sprintf(t, "sbc $%0.2x,s     [$%0.6x]", op8, decode(OPTYPE_SR, op8)); break;
-  case 0xe4: sprintf(t, "cpx $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0xe5: sprintf(t, "sbc $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0xe6: sprintf(t, "inc $%0.2x       [$%0.6x]", op8, decode(OPTYPE_DP, op8)); break;
-  case 0xe7: sprintf(t, "sbc [$%0.2x]     [$%0.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
-  case 0xe8: sprintf(t, "inx                    "); break;
-  case 0xe9: if(a8)sprintf(t, "sbc #$%0.2x               ", op8);
-             else  sprintf(t, "sbc #$%0.4x             ", op16); break;
-  case 0xea: sprintf(t, "nop                    "); break;
-  case 0xeb: sprintf(t, "xba                    "); break;
-  case 0xec: sprintf(t, "cpx $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0xed: sprintf(t, "sbc $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0xee: sprintf(t, "inc $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0xef: sprintf(t, "sbc $%0.6x   [$%0.6x]", op24, decode(OPTYPE_LONG, op24)); break;
-  case 0xf0: sprintf(t, "beq $%0.4x     [$%0.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
-  case 0xf1: sprintf(t, "sbc ($%0.2x),y   [$%0.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
-  case 0xf2: sprintf(t, "sbc ($%0.2x)     [$%0.6x]", op8, decode(OPTYPE_IDP, op8)); break;
-  case 0xf3: sprintf(t, "sbc ($%0.2x,s),y [$%0.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
-  case 0xf4: sprintf(t, "pea $%0.4x     [$%0.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
-  case 0xf5: sprintf(t, "sbc $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0xf6: sprintf(t, "inc $%0.2x,x     [$%0.6x]", op8, decode(OPTYPE_DPX, op8)); break;
-  case 0xf7: sprintf(t, "sbc [$%0.2x],y   [$%0.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
-  case 0xf8: sprintf(t, "sed                    "); break;
-  case 0xf9: sprintf(t, "sbc $%0.4x,y   [$%0.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
-  case 0xfa: sprintf(t, "plx                    "); break;
-  case 0xfb: sprintf(t, "xce                    "); break;
-  case 0xfc: sprintf(t, "jsr ($%0.4x,x) [$%0.6x]", op16, decode(OPTYPE_IADDRX, op16)); break;
-  case 0xfd: sprintf(t, "sbc $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0xfe: sprintf(t, "inc $%0.4x,x   [$%0.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
-  case 0xff: sprintf(t, "sbc $%0.6x,x [$%0.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
+    case 0x00: sprintf(t, "brk #$%.2x               ", op8); break;
+    case 0x01: sprintf(t, "ora ($%.2x,x)   [$%.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
+    case 0x02: sprintf(t, "cop #$%.2x               ", op8); break;
+    case 0x03: sprintf(t, "ora $%.2x,s     [$%.6x]", op8, decode(OPTYPE_SR, op8)); break;
+    case 0x04: sprintf(t, "tsb $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x05: sprintf(t, "ora $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x06: sprintf(t, "asl $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x07: sprintf(t, "ora [$%.2x]     [$%.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
+    case 0x08: sprintf(t, "php                    "); break;
+    case 0x09: if(a8)sprintf(t, "ora #$%.2x               ", op8);
+               else  sprintf(t, "ora #$%.4x             ", op16); break;
+    case 0x0a: sprintf(t, "asl a                  "); break;
+    case 0x0b: sprintf(t, "phd                    "); break;
+    case 0x0c: sprintf(t, "tsb $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x0d: sprintf(t, "ora $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x0e: sprintf(t, "asl $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x0f: sprintf(t, "ora $%.6x   [$%.6x]", op24, decode(OPTYPE_LONG, op24)); break;
+    case 0x10: sprintf(t, "bpl $%.4x     [$%.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
+    case 0x11: sprintf(t, "ora ($%.2x),y   [$%.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
+    case 0x12: sprintf(t, "ora ($%.2x)     [$%.6x]", op8, decode(OPTYPE_IDP, op8)); break;
+    case 0x13: sprintf(t, "ora ($%.2x,s),y [$%.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
+    case 0x14: sprintf(t, "trb $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x15: sprintf(t, "ora $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x16: sprintf(t, "asl $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x17: sprintf(t, "ora [$%.2x],y   [$%.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
+    case 0x18: sprintf(t, "clc                    "); break;
+    case 0x19: sprintf(t, "ora $%.4x,y   [$%.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
+    case 0x1a: sprintf(t, "inc                    "); break;
+    case 0x1b: sprintf(t, "tcs                    "); break;
+    case 0x1c: sprintf(t, "trb $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x1d: sprintf(t, "ora $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0x1e: sprintf(t, "asl $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0x1f: sprintf(t, "ora $%.6x,x [$%.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
+    case 0x20: sprintf(t, "jsr $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR_PC, op16)); break;
+    case 0x21: sprintf(t, "and ($%.2x,x)   [$%.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
+    case 0x22: sprintf(t, "jsl $%.6x   [$%.6x]", op24, decode(OPTYPE_LONG, op24)); break;
+    case 0x23: sprintf(t, "and $%.2x,s     [$%.6x]", op8, decode(OPTYPE_SR, op8)); break;
+    case 0x24: sprintf(t, "bit $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x25: sprintf(t, "and $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x26: sprintf(t, "rol $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x27: sprintf(t, "and [$%.2x]     [$%.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
+    case 0x28: sprintf(t, "plp                    "); break;
+    case 0x29: if(a8)sprintf(t, "and #$%.2x               ", op8);
+               else  sprintf(t, "and #$%.4x             ", op16); break;
+    case 0x2a: sprintf(t, "rol a                  "); break;
+    case 0x2b: sprintf(t, "pld                    "); break;
+    case 0x2c: sprintf(t, "bit $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x2d: sprintf(t, "and $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x2e: sprintf(t, "rol $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x2f: sprintf(t, "and $%.6x   [$%.6x]", op24, decode(OPTYPE_LONG, op24)); break;
+    case 0x30: sprintf(t, "bmi $%.4x     [$%.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
+    case 0x31: sprintf(t, "and ($%.2x),y   [$%.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
+    case 0x32: sprintf(t, "and ($%.2x)     [$%.6x]", op8, decode(OPTYPE_IDP, op8)); break;
+    case 0x33: sprintf(t, "and ($%.2x,s),y [$%.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
+    case 0x34: sprintf(t, "bit $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x35: sprintf(t, "and $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x36: sprintf(t, "rol $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x37: sprintf(t, "and [$%.2x],y   [$%.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
+    case 0x38: sprintf(t, "sec                    "); break;
+    case 0x39: sprintf(t, "and $%.4x,y   [$%.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
+    case 0x3a: sprintf(t, "dec                    "); break;
+    case 0x3b: sprintf(t, "tsc                    "); break;
+    case 0x3c: sprintf(t, "bit $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0x3d: sprintf(t, "and $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0x3e: sprintf(t, "rol $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0x3f: sprintf(t, "and $%.6x,x [$%.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
+    case 0x40: sprintf(t, "rti                    "); break;
+    case 0x41: sprintf(t, "eor ($%.2x,x)   [$%.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
+    case 0x42: sprintf(t, "wdm                    "); break;
+    case 0x43: sprintf(t, "eor $%.2x,s     [$%.6x]", op8, decode(OPTYPE_SR, op8)); break;
+    case 0x44: sprintf(t, "mvp $%.2x,$%.2x            ", op1, op8); break;
+    case 0x45: sprintf(t, "eor $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x46: sprintf(t, "lsr $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x47: sprintf(t, "eor [$%.2x]     [$%.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
+    case 0x48: sprintf(t, "pha                    "); break;
+    case 0x49: if(a8)sprintf(t, "eor #$%.2x               ", op8);
+               else  sprintf(t, "eor #$%.4x             ", op16); break;
+    case 0x4a: sprintf(t, "lsr a                  "); break;
+    case 0x4b: sprintf(t, "phk                    "); break;
+    case 0x4c: sprintf(t, "jmp $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR_PC, op16)); break;
+    case 0x4d: sprintf(t, "eor $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x4e: sprintf(t, "lsr $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x4f: sprintf(t, "eor $%.6x   [$%.6x]", op24, decode(OPTYPE_LONG, op24)); break;
+    case 0x50: sprintf(t, "bvc $%.4x     [$%.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
+    case 0x51: sprintf(t, "eor ($%.2x),y   [$%.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
+    case 0x52: sprintf(t, "eor ($%.2x)     [$%.6x]", op8, decode(OPTYPE_IDP, op8)); break;
+    case 0x53: sprintf(t, "eor ($%.2x,s),y [$%.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
+    case 0x54: sprintf(t, "mvn $%.2x,$%.2x            ", op1, op8); break;
+    case 0x55: sprintf(t, "eor $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x56: sprintf(t, "lsr $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x57: sprintf(t, "eor [$%.2x],y   [$%.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
+    case 0x58: sprintf(t, "cli                    "); break;
+    case 0x59: sprintf(t, "eor $%.4x,y   [$%.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
+    case 0x5a: sprintf(t, "phy                    "); break;
+    case 0x5b: sprintf(t, "tcd                    "); break;
+    case 0x5c: sprintf(t, "jml $%.6x   [$%.6x]", op24, decode(OPTYPE_LONG, op24)); break;
+    case 0x5d: sprintf(t, "eor $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0x5e: sprintf(t, "lsr $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0x5f: sprintf(t, "eor $%.6x,x [$%.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
+    case 0x60: sprintf(t, "rts                    "); break;
+    case 0x61: sprintf(t, "adc ($%.2x,x)   [$%.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
+    case 0x62: sprintf(t, "per $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x63: sprintf(t, "adc $%.2x,s     [$%.6x]", op8, decode(OPTYPE_SR, op8)); break;
+    case 0x64: sprintf(t, "stz $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x65: sprintf(t, "adc $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x66: sprintf(t, "ror $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x67: sprintf(t, "adc [$%.2x]     [$%.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
+    case 0x68: sprintf(t, "pla                    "); break;
+    case 0x69: if(a8)sprintf(t, "adc #$%.2x               ", op8);
+               else  sprintf(t, "adc #$%.4x             ", op16); break;
+    case 0x6a: sprintf(t, "ror a                  "); break;
+    case 0x6b: sprintf(t, "rtl                    "); break;
+    case 0x6c: sprintf(t, "jmp ($%.4x)   [$%.6x]", op16, decode(OPTYPE_IADDR_PC, op16)); break;
+    case 0x6d: sprintf(t, "adc $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x6e: sprintf(t, "ror $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x6f: sprintf(t, "adc $%.6x   [$%.6x]", op24, decode(OPTYPE_LONG, op24)); break;
+    case 0x70: sprintf(t, "bvs $%.4x     [$%.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
+    case 0x71: sprintf(t, "adc ($%.2x),y   [$%.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
+    case 0x72: sprintf(t, "adc ($%.2x)     [$%.6x]", op8, decode(OPTYPE_IDP, op8)); break;
+    case 0x73: sprintf(t, "adc ($%.2x,s),y [$%.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
+    case 0x74: sprintf(t, "stz $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x75: sprintf(t, "adc $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x76: sprintf(t, "ror $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x77: sprintf(t, "adc [$%.2x],y   [$%.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
+    case 0x78: sprintf(t, "sei                    "); break;
+    case 0x79: sprintf(t, "adc $%.4x,y   [$%.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
+    case 0x7a: sprintf(t, "ply                    "); break;
+    case 0x7b: sprintf(t, "tdc                    "); break;
+    case 0x7c: sprintf(t, "jmp ($%.4x,x) [$%.6x]", op16, decode(OPTYPE_IADDRX, op16)); break;
+    case 0x7d: sprintf(t, "adc $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0x7e: sprintf(t, "ror $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0x7f: sprintf(t, "adc $%.6x,x [$%.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
+    case 0x80: sprintf(t, "bra $%.4x     [$%.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
+    case 0x81: sprintf(t, "sta ($%.2x,x)   [$%.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
+    case 0x82: sprintf(t, "brl $%.4x     [$%.6x]", uint16(decode(OPTYPE_RELW, op16)), decode(OPTYPE_RELW, op16)); break;
+    case 0x83: sprintf(t, "sta $%.2x,s     [$%.6x]", op8, decode(OPTYPE_SR, op8)); break;
+    case 0x84: sprintf(t, "sty $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x85: sprintf(t, "sta $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x86: sprintf(t, "stx $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0x87: sprintf(t, "sta [$%.2x]     [$%.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
+    case 0x88: sprintf(t, "dey                    "); break;
+    case 0x89: if(a8)sprintf(t, "bit #$%.2x               ", op8);
+               else  sprintf(t, "bit #$%.4x             ", op16); break;
+    case 0x8a: sprintf(t, "txa                    "); break;
+    case 0x8b: sprintf(t, "phb                    "); break;
+    case 0x8c: sprintf(t, "sty $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x8d: sprintf(t, "sta $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x8e: sprintf(t, "stx $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x8f: sprintf(t, "sta $%.6x   [$%.6x]", op24, decode(OPTYPE_LONG, op24)); break;
+    case 0x90: sprintf(t, "bcc $%.4x     [$%.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
+    case 0x91: sprintf(t, "sta ($%.2x),y   [$%.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
+    case 0x92: sprintf(t, "sta ($%.2x)     [$%.6x]", op8, decode(OPTYPE_IDP, op8)); break;
+    case 0x93: sprintf(t, "sta ($%.2x,s),y [$%.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
+    case 0x94: sprintf(t, "sty $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x95: sprintf(t, "sta $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0x96: sprintf(t, "stx $%.2x,y     [$%.6x]", op8, decode(OPTYPE_DPY, op8)); break;
+    case 0x97: sprintf(t, "sta [$%.2x],y   [$%.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
+    case 0x98: sprintf(t, "tya                    "); break;
+    case 0x99: sprintf(t, "sta $%.4x,y   [$%.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
+    case 0x9a: sprintf(t, "txs                    "); break;
+    case 0x9b: sprintf(t, "txy                    "); break;
+    case 0x9c: sprintf(t, "stz $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0x9d: sprintf(t, "sta $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0x9e: sprintf(t, "stz $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0x9f: sprintf(t, "sta $%.6x,x [$%.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
+    case 0xa0: if(x8)sprintf(t, "ldy #$%.2x               ", op8);
+               else  sprintf(t, "ldy #$%.4x             ", op16); break;
+    case 0xa1: sprintf(t, "lda ($%.2x,x)   [$%.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
+    case 0xa2: if(x8)sprintf(t, "ldx #$%.2x               ", op8);
+               else  sprintf(t, "ldx #$%.4x             ", op16); break;
+    case 0xa3: sprintf(t, "lda $%.2x,s     [$%.6x]", op8, decode(OPTYPE_SR, op8)); break;
+    case 0xa4: sprintf(t, "ldy $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0xa5: sprintf(t, "lda $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0xa6: sprintf(t, "ldx $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0xa7: sprintf(t, "lda [$%.2x]     [$%.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
+    case 0xa8: sprintf(t, "tay                    "); break;
+    case 0xa9: if(a8)sprintf(t, "lda #$%.2x               ", op8);
+               else  sprintf(t, "lda #$%.4x             ", op16); break;
+    case 0xaa: sprintf(t, "tax                    "); break;
+    case 0xab: sprintf(t, "plb                    "); break;
+    case 0xac: sprintf(t, "ldy $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0xad: sprintf(t, "lda $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0xae: sprintf(t, "ldx $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0xaf: sprintf(t, "lda $%.6x   [$%.6x]", op24, decode(OPTYPE_LONG, op24)); break;
+    case 0xb0: sprintf(t, "bcs $%.4x     [$%.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
+    case 0xb1: sprintf(t, "lda ($%.2x),y   [$%.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
+    case 0xb2: sprintf(t, "lda ($%.2x)     [$%.6x]", op8, decode(OPTYPE_IDP, op8)); break;
+    case 0xb3: sprintf(t, "lda ($%.2x,s),y [$%.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
+    case 0xb4: sprintf(t, "ldy $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0xb5: sprintf(t, "lda $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0xb6: sprintf(t, "ldx $%.2x,y     [$%.6x]", op8, decode(OPTYPE_DPY, op8)); break;
+    case 0xb7: sprintf(t, "lda [$%.2x],y   [$%.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
+    case 0xb8: sprintf(t, "clv                    "); break;
+    case 0xb9: sprintf(t, "lda $%.4x,y   [$%.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
+    case 0xba: sprintf(t, "tsx                    "); break;
+    case 0xbb: sprintf(t, "tyx                    "); break;
+    case 0xbc: sprintf(t, "ldy $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0xbd: sprintf(t, "lda $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0xbe: sprintf(t, "ldx $%.4x,y   [$%.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
+    case 0xbf: sprintf(t, "lda $%.6x,x [$%.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
+    case 0xc0: if(x8)sprintf(t, "cpy #$%.2x               ", op8);
+               else  sprintf(t, "cpy #$%.4x             ", op16); break;
+    case 0xc1: sprintf(t, "cmp ($%.2x,x)   [$%.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
+    case 0xc2: sprintf(t, "rep #$%.2x               ", op8); break;
+    case 0xc3: sprintf(t, "cmp $%.2x,s     [$%.6x]", op8, decode(OPTYPE_SR, op8)); break;
+    case 0xc4: sprintf(t, "cpy $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0xc5: sprintf(t, "cmp $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0xc6: sprintf(t, "dec $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0xc7: sprintf(t, "cmp [$%.2x]     [$%.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
+    case 0xc8: sprintf(t, "iny                    "); break;
+    case 0xc9: if(a8)sprintf(t, "cmp #$%.2x               ", op8);
+               else  sprintf(t, "cmp #$%.4x             ", op16); break;
+    case 0xca: sprintf(t, "dex                    "); break;
+    case 0xcb: sprintf(t, "wai                    "); break;
+    case 0xcc: sprintf(t, "cpy $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0xcd: sprintf(t, "cmp $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0xce: sprintf(t, "dec $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0xcf: sprintf(t, "cmp $%.6x   [$%.6x]", op24, decode(OPTYPE_LONG, op24)); break;
+    case 0xd0: sprintf(t, "bne $%.4x     [$%.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
+    case 0xd1: sprintf(t, "cmp ($%.2x),y   [$%.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
+    case 0xd2: sprintf(t, "cmp ($%.2x)     [$%.6x]", op8, decode(OPTYPE_IDP, op8)); break;
+    case 0xd3: sprintf(t, "cmp ($%.2x,s),y [$%.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
+    case 0xd4: sprintf(t, "pei ($%.2x)     [$%.6x]", op8, decode(OPTYPE_IDP, op8)); break;
+    case 0xd5: sprintf(t, "cmp $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0xd6: sprintf(t, "dec $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0xd7: sprintf(t, "cmp [$%.2x],y   [$%.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
+    case 0xd8: sprintf(t, "cld                    "); break;
+    case 0xd9: sprintf(t, "cmp $%.4x,y   [$%.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
+    case 0xda: sprintf(t, "phx                    "); break;
+    case 0xdb: sprintf(t, "stp                    "); break;
+    case 0xdc: sprintf(t, "jmp [$%.4x]   [$%.6x]", op16, decode(OPTYPE_ILADDR, op16)); break;
+    case 0xdd: sprintf(t, "cmp $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0xde: sprintf(t, "dec $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0xdf: sprintf(t, "cmp $%.6x,x [$%.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
+    case 0xe0: if(x8)sprintf(t, "cpx #$%.2x               ", op8);
+               else  sprintf(t, "cpx #$%.4x             ", op16); break;
+    case 0xe1: sprintf(t, "sbc ($%.2x,x)   [$%.6x]", op8, decode(OPTYPE_IDPX, op8)); break;
+    case 0xe2: sprintf(t, "sep #$%.2x               ", op8); break;
+    case 0xe3: sprintf(t, "sbc $%.2x,s     [$%.6x]", op8, decode(OPTYPE_SR, op8)); break;
+    case 0xe4: sprintf(t, "cpx $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0xe5: sprintf(t, "sbc $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0xe6: sprintf(t, "inc $%.2x       [$%.6x]", op8, decode(OPTYPE_DP, op8)); break;
+    case 0xe7: sprintf(t, "sbc [$%.2x]     [$%.6x]", op8, decode(OPTYPE_ILDP, op8)); break;
+    case 0xe8: sprintf(t, "inx                    "); break;
+    case 0xe9: if(a8)sprintf(t, "sbc #$%.2x               ", op8);
+               else  sprintf(t, "sbc #$%.4x             ", op16); break;
+    case 0xea: sprintf(t, "nop                    "); break;
+    case 0xeb: sprintf(t, "xba                    "); break;
+    case 0xec: sprintf(t, "cpx $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0xed: sprintf(t, "sbc $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0xee: sprintf(t, "inc $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0xef: sprintf(t, "sbc $%.6x   [$%.6x]", op24, decode(OPTYPE_LONG, op24)); break;
+    case 0xf0: sprintf(t, "beq $%.4x     [$%.6x]", uint16(decode(OPTYPE_RELB, op8)), decode(OPTYPE_RELB, op8)); break;
+    case 0xf1: sprintf(t, "sbc ($%.2x),y   [$%.6x]", op8, decode(OPTYPE_IDPY, op8)); break;
+    case 0xf2: sprintf(t, "sbc ($%.2x)     [$%.6x]", op8, decode(OPTYPE_IDP, op8)); break;
+    case 0xf3: sprintf(t, "sbc ($%.2x,s),y [$%.6x]", op8, decode(OPTYPE_ISRY, op8)); break;
+    case 0xf4: sprintf(t, "pea $%.4x     [$%.6x]", op16, decode(OPTYPE_ADDR, op16)); break;
+    case 0xf5: sprintf(t, "sbc $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0xf6: sprintf(t, "inc $%.2x,x     [$%.6x]", op8, decode(OPTYPE_DPX, op8)); break;
+    case 0xf7: sprintf(t, "sbc [$%.2x],y   [$%.6x]", op8, decode(OPTYPE_ILDPY, op8)); break;
+    case 0xf8: sprintf(t, "sed                    "); break;
+    case 0xf9: sprintf(t, "sbc $%.4x,y   [$%.6x]", op16, decode(OPTYPE_ADDRY, op16)); break;
+    case 0xfa: sprintf(t, "plx                    "); break;
+    case 0xfb: sprintf(t, "xce                    "); break;
+    case 0xfc: sprintf(t, "jsr ($%.4x,x) [$%.6x]", op16, decode(OPTYPE_IADDRX, op16)); break;
+    case 0xfd: sprintf(t, "sbc $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0xfe: sprintf(t, "inc $%.4x,x   [$%.6x]", op16, decode(OPTYPE_ADDRX, op16)); break;
+    case 0xff: sprintf(t, "sbc $%.6x,x [$%.6x]", op24, decode(OPTYPE_LONGX, op24)); break;
   }
-#undef op8
-#undef op16
-#undef op24
-#undef a8
-#undef x8
+
+  #undef op8
+  #undef op16
+  #undef op24
+  #undef a8
+  #undef x8
 
   strcat(s, t);
   strcat(s, " ");
 
-  sprintf(t, "A:%0.4x X:%0.4x Y:%0.4x S:%0.4x D:%0.4x DB:%0.2x ",
+  sprintf(t, "A:%.4x X:%.4x Y:%.4x S:%.4x D:%.4x DB:%.2x ",
     regs.a.w, regs.x.w, regs.y.w, regs.s.w, regs.d.w, regs.db);
   strcat(s, t);
 
   if(regs.e) {
     sprintf(t, "%c%c%c%c%c%c%c%c",
-      (regs.p.n) ? 'N' : 'n', (regs.p.v) ? 'V' : 'v',
-      (regs.p.m) ? '1' : '0', (regs.p.x) ? 'B' : 'b',
-      (regs.p.d) ? 'D' : 'd', (regs.p.i) ? 'I' : 'i',
-      (regs.p.z) ? 'Z' : 'z', (regs.p.c) ? 'C' : 'c');
+      regs.p.n ? 'N' : 'n', regs.p.v ? 'V' : 'v',
+      regs.p.m ? '1' : '0', regs.p.x ? 'B' : 'b',
+      regs.p.d ? 'D' : 'd', regs.p.i ? 'I' : 'i',
+      regs.p.z ? 'Z' : 'z', regs.p.c ? 'C' : 'c');
   } else {
     sprintf(t, "%c%c%c%c%c%c%c%c",
-      (regs.p.n) ? 'N' : 'n', (regs.p.v) ? 'V' : 'v',
-      (regs.p.m) ? 'M' : 'm', (regs.p.x) ? 'X' : 'x',
-      (regs.p.d) ? 'D' : 'd', (regs.p.i) ? 'I' : 'i',
-      (regs.p.z) ? 'Z' : 'z', (regs.p.c) ? 'C' : 'c');
+      regs.p.n ? 'N' : 'n', regs.p.v ? 'V' : 'v',
+      regs.p.m ? 'M' : 'm', regs.p.x ? 'X' : 'x',
+      regs.p.d ? 'D' : 'd', regs.p.i ? 'I' : 'i',
+      regs.p.z ? 'Z' : 'z', regs.p.c ? 'C' : 'c');
   }
 
   strcat(s, t);
   strcat(s, " ");
 
-  sprintf(t, "V:%3d H:%4d", ppucounter.vcounter(), ppucounter.hcounter());
+  sprintf(t, "V:%3d H:%4d", ppu.vcounter(), ppu.hcounter());
   strcat(s, t);
 }
 
-/*****
- * opcode_length() retrieves the length of the next opcode
- * to be executed. It is used by the debugger to step over,
- * disable and proceed cpu opcodes.
- *
- * 5 and 6 are special cases, 5 is used for #consts based on
- * the A register size, 6 for the X/Y register size. the
- * rest are literal sizes. There's no need to test for
- * emulation mode, as regs.p.m/regs.p.x should *always* be
- * set in emulation mode.
- *****/
+//opcode_length() retrieves the length of the next opcode
+//to be executed. It is used by the debugger to step over,
+//disable and proceed cpu opcodes.
+//
+//5 and 6 are special cases, 5 is used for #consts based on
+//the A register size, 6 for the X/Y register size. the
+//rest are literal sizes. There's no need to test for
+//emulation mode, as regs.p.m/regs.p.x should *always* be
+//set in emulation mode.
+
 uint8 CPU::opcode_length() {
-uint8 op, len;
-static uint8 op_len_tbl[256] = {
-//0,1,2,3,  4,5,6,7,  8,9,a,b,  c,d,e,f
+  uint8 op, len;
+  static uint8 op_len_tbl[256] = {
+  //0,1,2,3,  4,5,6,7,  8,9,a,b,  c,d,e,f
 
-  2,2,2,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0x0n
-  2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0x1n
-  3,2,4,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0x2n
-  2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0x3n
+    2,2,2,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0x0n
+    2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0x1n
+    3,2,4,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0x2n
+    2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0x3n
 
-  1,2,2,2,  3,2,2,2,  1,5,1,1,  3,3,3,4, //0x4n
-  2,2,2,2,  3,2,2,2,  1,3,1,1,  4,3,3,4, //0x5n
-  1,2,3,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0x6n
-  2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0x7n
+    1,2,2,2,  3,2,2,2,  1,5,1,1,  3,3,3,4, //0x4n
+    2,2,2,2,  3,2,2,2,  1,3,1,1,  4,3,3,4, //0x5n
+    1,2,3,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0x6n
+    2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0x7n
 
-  2,2,3,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0x8n
-  2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0x9n
-  6,2,6,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0xan
-  2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0xbn
+    2,2,3,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0x8n
+    2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0x9n
+    6,2,6,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0xan
+    2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0xbn
+
+    6,2,2,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0xcn
+    2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0xdn
+    6,2,2,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0xen
+    2,2,2,2,  3,2,2,2,  1,3,1,1,  3,3,3,4  //0xfn
+  };
 
-  6,2,2,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0xcn
-  2,2,2,2,  2,2,2,2,  1,3,1,1,  3,3,3,4, //0xdn
-  6,2,2,2,  2,2,2,2,  1,5,1,1,  3,3,3,4, //0xen
-  2,2,2,2,  3,2,2,2,  1,3,1,1,  3,3,3,4  //0xfn
-};
   if(in_opcode() == true) {
     return 0;
   }
 
   op  = dreadb(regs.pc.d);
   len = op_len_tbl[op];
-  if(len == 5)return (regs.e || regs.p.m) ? 2 : 3;
-  if(len == 6)return (regs.e || regs.p.x) ? 2 : 3;
+  if(len == 5) return (regs.e || regs.p.m) ? 2 : 3;
+  if(len == 6) return (regs.e || regs.p.x) ? 2 : 3;
   return len;
 }
 
-#endif //ifdef CPU_CPP
+#endif  //ifdef CPU_CPP

src/cpu/scpu/core/core.cpp

@@ -10,14 +10,14 @@ void sCPU::enter() {
   add_clocks(186);
 
   loop:
-  if(event.irq) {
-    event.irq = false;
-    if(status.nmi_pending == true) {
+  if(status.interrupt_pending) {
+    status.interrupt_pending = false;
+    if(status.nmi_pending) {
       status.nmi_pending = false;
-      event.irq_vector = (regs.e == false) ? 0xffea : 0xfffa;
-    } else if(status.irq_pending == true) {
+      status.interrupt_vector = (regs.e == false ? 0xffea : 0xfffa);
+    } else if(status.irq_pending) {
       status.irq_pending = false;
-      event.irq_vector = (regs.e == false) ? 0xffee : 0xfffe;
+      status.interrupt_vector = (regs.e == false ? 0xffee : 0xfffe);
     }
     op_irq();
   }
@@ -40,15 +40,15 @@ void sCPU::enter() {
 void sCPU::op_irq() {
   op_read(regs.pc.d);
   op_io();
-  if(!regs.e)op_writestack(regs.pc.b);
+  if(!regs.e) op_writestack(regs.pc.b);
   op_writestack(regs.pc.h);
   op_writestack(regs.pc.l);
   op_writestack(regs.e ? (regs.p & ~0x10) : regs.p);
-  rd.l = op_read(event.irq_vector + 0);
+  rd.l = op_read(status.interrupt_vector + 0);
   regs.pc.b = 0x00;
   regs.p.i  = 1;
   regs.p.d  = 0;
-  rd.h = op_read(event.irq_vector + 1);
+  rd.h = op_read(status.interrupt_vector + 1);
   regs.pc.w = rd.w;
 }
 
@@ -57,11 +57,11 @@ void sCPU::op_irq() {
 //this affects the following opcodes:
 //  clc, cld, cli, clv, sec, sed, sei,
 //  tax, tay, txa, txy, tya, tyx,
-//  tcd, tcs, tdc, tsc, tsx, tcs,
+//  tcd, tcs, tdc, tsc, tsx, txs,
 //  inc, inx, iny, dec, dex, dey,
 //  asl, lsr, rol, ror, nop, xce.
 alwaysinline void sCPU::op_io_irq() {
-  if(event.irq) {
+  if(status.interrupt_pending) {
     //IRQ pending, modify I/O cycle to bus read cycle, do not increment PC
     op_read(regs.pc.d);
   } else {
@@ -87,4 +87,4 @@ alwaysinline void sCPU::op_io_cond6(uint16 addr) {
   }
 }
 
-#endif //ifdef SCPU_CPP
+#endif

src/cpu/scpu/core/op_misc.b

@@ -62,9 +62,9 @@ stp(0xdb) {
 }
 
 wai(0xcb) {
-//last_cycle() will clear event.wai once an NMI / IRQ edge is reached
-1:event.wai = true;
-  while(event.wai) {
+//last_cycle() will clear status.wai_lock once an NMI / IRQ edge is reached
+1:status.wai_lock = true;
+  while(status.wai_lock) {
     last_cycle();
     op_io();
   }

src/cpu/scpu/core/op_misc.cpp

@@ -1,3 +1,5 @@
+#ifdef SCPU_CPP
+
 //nop
 case 0xea: {
   last_cycle();
@@ -103,9 +105,9 @@ case 0xdb: {
 
 //wai
 case 0xcb: {
-  //last_cycle() will clear event.wai once an NMI / IRQ edge is reached
-  event.wai = true;
-  while(event.wai) {
+  //last_cycle() will clear status.wai_lock once an NMI / IRQ edge is reached
+  status.wai_lock = true;
+  while(status.wai_lock) {
     last_cycle();
     op_io();
   }
@@ -534,3 +536,4 @@ case 0x62: {
   if(regs.e) regs.s.h = 0x01;
 } break;
 
+#endif

src/cpu/scpu/core/op_pc.cpp

@@ -1,3 +1,5 @@
+#ifdef SCPU_CPP
+
 //bcc
 case 0x90: {
   if(!!regs.p.c) last_cycle();
@@ -274,3 +276,4 @@ case 0x6b: {
   if(regs.e) regs.s.h = 0x01;
 } break;
 
+#endif

src/cpu/scpu/core/op_read.cpp

@@ -1,3 +1,5 @@
+#ifdef SCPU_CPP
+
 //adc_const
 case 0x69: {
   if(regs.p.m) last_cycle();
@@ -1649,3 +1651,4 @@ case 0x89: {
   regs.p.z = ((rd.w & regs.a.w) == 0);
 } break;
 
+#endif

src/cpu/scpu/core/op_rmw.cpp

@@ -1,3 +1,5 @@
+#ifdef SCPU_CPP
+
 //inc
 case 0x1a: {
   last_cycle();
@@ -568,3 +570,4 @@ case 0x76: {
   op_writedp(dp + regs.x.w,     rd.l);
 } break;
 
+#endif

src/cpu/scpu/core/op_write.cpp

@@ -1,3 +1,5 @@
+#ifdef SCPU_CPP
+
 //sta_addr
 case 0x8d: {
   aa.l = op_readpc();
@@ -288,3 +290,4 @@ case 0x93: {
   op_writedbr(aa.w + regs.y.w + 1, regs.a.h);
 } break;
 
+#endif

src/cpu/scpu/dma/dma.cpp

@@ -1,6 +1,6 @@
 #ifdef SCPU_CPP
 
-void sCPU::dma_add_clocks(uint clocks) {
+void sCPU::dma_add_clocks(unsigned clocks) {
   status.dma_clocks += clocks;
   add_clocks(clocks);
 }
@@ -121,7 +121,8 @@ void sCPU::dma_run() {
     channel[i].dma_enabled = false;
   }
 
-  counter.set(counter.irq_delay, 2);
+  status.irq_lock = true;
+  event.enqueue(2, EventIrqLockRelease);
 }
 
 /*****
@@ -203,7 +204,8 @@ void sCPU::hdma_run() {
     }
   }
 
-  counter.set(counter.irq_delay, 2);
+  status.irq_lock = true;
+  event.enqueue(2, EventIrqLockRelease);
 }
 
 void sCPU::hdma_init_reset() {
@@ -224,7 +226,8 @@ void sCPU::hdma_init() {
     hdma_update(i);
   }
 
-  counter.set(counter.irq_delay, 2);
+  status.irq_lock = true;
+  event.enqueue(2, EventIrqLockRelease);
 }
 
 /*****

src/cpu/scpu/dma/dma.hpp

@@ -45,7 +45,7 @@
     bool   hdma_do_transfer;
   } channel[8];
 
-  void dma_add_clocks(uint clocks);
+  void dma_add_clocks(unsigned clocks);
   bool dma_addr_valid(uint32 abus);
   uint8 dma_read(uint32 abus);
   void dma_transfer(bool direction, uint8 bbus, uint32 abus);

src/cpu/scpu/mmio/mmio.hpp

@@ -1,7 +1,7 @@
   void mmio_power();
   void mmio_reset();
-  uint8 mmio_read(uint addr);
-  void mmio_write(uint addr, uint8 data);
+  uint8 mmio_read(unsigned addr);
+  void mmio_write(unsigned addr, uint8 data);
 
   uint8 pio();
   bool joylatch();

src/cpu/scpu/scpu.cpp

@@ -1,6 +1,9 @@
-#include <../base.hpp>
+#include <../base.hpp>
 #define SCPU_CPP
 
+#include <nall/priorityqueue.hpp>
+priority_queue<unsigned> event(512, bind(&sCPU::queue_event, &cpu));
+
 #include "core/core.cpp"
 #include "dma/dma.cpp"
 #include "memory/memory.cpp"
@@ -8,6 +11,8 @@
 #include "timing/timing.cpp"
 
 void sCPU::power() {
+  CPU::power();
+
   regs.a = regs.x = regs.y = 0x0000;
   regs.s = 0x01ff;
 
@@ -19,6 +24,8 @@ void sCPU::power() {
 }
 
 void sCPU::reset() {
+  CPU::reset();
+
   regs.pc.d = 0x000000;
   regs.pc.l = bus.read(0xfffc);
   regs.pc.h = bus.read(0xfffd);
@@ -33,9 +40,9 @@ void sCPU::reset() {
   regs.e    = 1;
   regs.mdr  = 0x00;
 
-  event.wai = false;
-  event.irq = false;
-  event.irq_vector = 0xfffc; //reset vector address
+  status.wai_lock = false;
+  status.interrupt_pending = false;
+  status.interrupt_vector  = 0xfffc;  //reset vector address
 
   mmio_reset();
   dma_reset();

src/cpu/scpu/scpu.hpp

@@ -8,75 +8,46 @@ public:
   #include "mmio/mmio.hpp"
   #include "timing/timing.hpp"
 
-  struct {
-    bool wai;
-    bool irq;
-    uint16 irq_vector;
-  } event;
-
-  struct {
-    unsigned nmi_hold;
-    unsigned irq_hold;
-
-    unsigned nmi_fire;
-    unsigned irq_fire;
-    unsigned irq_delay;
-    unsigned hw_math;
-
-    alwaysinline void set(uint &ctr, uint clocks) {
-      if(clocks >= ctr) { ctr = clocks; }
-    }
-
-    alwaysinline void sub(uint &ctr, uint clocks) {
-      if(ctr >= clocks) {
-        ctr -= clocks;
-      } else {
-        ctr  = 0;
-      }
-    }
-  } counter;
-
-  enum DMA_State { DMA_Inactive, DMA_Run, DMA_CPUsync };
+  enum DmaState { DmaInactive, DmaRun, DmaCpuSync };
 
   struct {
     //core
     uint8 opcode;
     bool in_opcode;
 
+    bool wai_lock;
+    bool interrupt_pending;
+    uint16 interrupt_vector;
+
     unsigned clock_count;
     unsigned line_clocks;
 
     //timing
-    bool dram_refreshed;
-    uint16 dram_refresh_position;
-
-    bool hdmainit_triggered;
-    uint16 hdmainit_trigger_position;
-
-    bool hdma_triggered;
-
-    uint16 irq_delay;
+    bool irq_lock;
+    bool alu_lock;
+    unsigned dram_refresh_position;
 
     bool nmi_valid;
     bool nmi_line;
     bool nmi_transition;
     bool nmi_pending;
+    bool nmi_hold;
 
-    uint16 virq_trigger_pos, hirq_trigger_pos;
     bool irq_valid;
     bool irq_line;
     bool irq_transition;
     bool irq_pending;
+    bool irq_hold;
 
-    //dma
+    //DMA
     unsigned dma_counter;
     unsigned dma_clocks;
     bool dma_pending;
     bool hdma_pending;
-    bool hdma_mode; //0 = init, 1 = run
-    DMA_State dma_state;
+    bool hdma_mode;  //0 = init, 1 = run
+    DmaState dma_state;
 
-    //mmio
+    //MMIO
 
     //$2181-$2183
     uint32 wram_addr;

src/cpu/scpu/timing/event.cpp

@@ -0,0 +1,35 @@
+#ifdef SCPU_CPP
+
+void sCPU::queue_event(unsigned id) {
+  switch(id) {
+    //interrupts triggered during (H)DMA do not trigger immediately after
+    case EventIrqLockRelease: {
+      status.irq_lock = false;
+    } break;
+
+    //ALU multiplication / division results are not immediately calculated;
+    //the exact formula for the calculations are unknown, but this lock at least
+    //allows emulation to avoid returning to fully computed results too soon.
+    case EventAluLockRelease: {
+      status.alu_lock = false;
+    } break;
+
+    //S-CPU WRAM consists of two 64kbyte DRAM chips, which must be refreshed
+    //once per scanline to avoid memory decay.
+    case EventDramRefresh: {
+      add_clocks(40);
+    } break;
+
+    //HDMA init routine; occurs once per frame
+    case EventHdmaInit: {
+      cycle_edge_state |= EventFlagHdmaInit;
+    } break;
+
+    //HDMA run routine; occurs once per scanline
+    case EventHdmaRun: {
+      cycle_edge_state |= EventFlagHdmaRun;
+    } break;
+  }
+}
+
+#endif

src/cpu/scpu/timing/irq.cpp

@@ -1,65 +1,47 @@
 #ifdef SCPU_CPP
 
-void sCPU::update_interrupts() {
-  unsigned vtime = status.virq_pos;
-  unsigned htime = status.hirq_enabled ? status.hirq_pos : 0;
-  unsigned vlimit = (snes.region() == SNES::NTSC ? 525 : 625) >> 1;
-
-  //an IRQ for the very last dot of a field cannot trigger an IRQ
-  if((vtime == (vlimit - 1) && htime == 339 && ppu.interlace() == false)
-  || (vtime == vlimit && htime == 339)
-  ) {
-    vtime = 0x03ff;
-    htime = 0x03ff;
-  }
-
-  status.virq_trigger_pos = vtime;
-  status.hirq_trigger_pos = 4 * (status.hirq_enabled ? htime + 1 : 0);
-}
-
-alwaysinline void sCPU::poll_interrupts() {
-  uint16_t vpos, hpos;
-
+//called once every four clock cycles;
+//as NMI steps by scanlines (divisible by 4) and IRQ by PPU 4-cycle dots.
+//
+//ppu.(vh)counter(n) returns the value of said counters n-clocks before current time;
+//it is used to emulate hardware communication delay between opcode and interrupt units.
+void sCPU::poll_interrupts() {
   //NMI hold
-  if(counter.nmi_hold) {
-    counter.nmi_hold -= 2;
-    if(counter.nmi_hold == 0) {
-      if(status.nmi_enabled == true) status.nmi_transition = true;
-    }
+  if(status.nmi_hold) {
+    status.nmi_hold = false;
+    if(status.nmi_enabled) status.nmi_transition = true;
   }
 
   //NMI test
-  vpos = ppucounter.vcounter(2);
-  hpos = ppucounter.hcounter(2);
-  bool nmi_valid = (vpos >= (!ppu.overscan() ? 225 : 240));
-  if(status.nmi_valid == false && nmi_valid == true) {
+  bool nmi_valid = (ppu.vcounter(2) >= (!ppu.overscan() ? 225 : 240));
+  if(!status.nmi_valid && nmi_valid) {
     //0->1 edge sensitive transition
     status.nmi_line = true;
-    counter.nmi_hold = 4;
-  } else if(status.nmi_valid == true && nmi_valid == false) {
+    status.nmi_hold = true;  //hold /NMI for four cycles
+  } else if(status.nmi_valid && !nmi_valid) {
     //1->0 edge sensitive transition
     status.nmi_line = false;
   }
   status.nmi_valid = nmi_valid;
 
   //IRQ hold
-  if(counter.irq_hold) counter.irq_hold -= 2;
-  if(status.irq_line == true && counter.irq_hold == 0) {
-    if(status.virq_enabled == true || status.hirq_enabled == true) status.irq_transition = true;
+  status.irq_hold = false;
+  if(status.irq_line) {
+    if(status.virq_enabled || status.hirq_enabled) status.irq_transition = true;
   }
 
   //IRQ test
-  vpos = ppucounter.vcounter(10);
-  hpos = ppucounter.hcounter(10);
-  bool irq_valid = (status.virq_enabled == true || status.hirq_enabled == true);
-  if(irq_valid == true) {
-    if(status.virq_enabled == true && vpos != status.virq_trigger_pos) irq_valid = false;
-    if(status.hirq_enabled == true && hpos != status.hirq_trigger_pos) irq_valid = false;
+  bool irq_valid = (status.virq_enabled || status.hirq_enabled);
+  if(irq_valid) {
+    if((status.virq_enabled && ppu.vcounter(10) != (status.virq_pos))
+    || (status.hirq_enabled && ppu.hcounter(10) != (status.hirq_pos + 1) * 4)
+    || (status.virq_pos && ppu.vcounter(6) == 0)  //IRQs cannot trigger on last dot of field
+    ) irq_valid = false;
   }
-  if(status.irq_valid == false && irq_valid == true) {
+  if(!status.irq_valid && irq_valid) {
     //0->1 edge sensitive transition
     status.irq_line = true;
-    counter.irq_hold = 4;
+    status.irq_hold = true;  //hold /IRQ for four cycles
   }
   status.irq_valid = irq_valid;
 }
@@ -68,36 +50,32 @@ void sCPU::nmitimen_update(uint8 data) {
   bool nmi_enabled  = status.nmi_enabled;
   bool virq_enabled = status.virq_enabled;
   bool hirq_enabled = status.hirq_enabled;
-  status.nmi_enabled  = !!(data & 0x80);
-  status.virq_enabled = !!(data & 0x20);
-  status.hirq_enabled = !!(data & 0x10);
+  status.nmi_enabled  = data & 0x80;
+  status.virq_enabled = data & 0x20;
+  status.hirq_enabled = data & 0x10;
 
   //0->1 edge sensitive transition
-  if(nmi_enabled == false && status.nmi_enabled == true && status.nmi_line == true) {
+  if(!nmi_enabled && status.nmi_enabled && status.nmi_line) {
     status.nmi_transition = true;
   }
 
   //?->1 level sensitive transition
-  if(status.virq_enabled == true && status.hirq_enabled == false && status.irq_line == true) {
+  if(status.virq_enabled && !status.hirq_enabled && status.irq_line) {
     status.irq_transition = true;
   }
 
-  if(status.virq_enabled == false && status.hirq_enabled == false) {
+  if(!status.virq_enabled && !status.hirq_enabled) {
     status.irq_line = false;
     status.irq_transition = false;
   }
 
-  update_interrupts();
-  counter.set(counter.irq_delay, 2);
-}
-
-void sCPU::hvtime_update(uint16 addr) {
-  update_interrupts();
+  status.irq_lock = true;
+  event.enqueue(2, EventIrqLockRelease);
 }
 
 bool sCPU::rdnmi() {
   bool result = status.nmi_line;
-  if(counter.nmi_hold == 0) {
+  if(!status.nmi_hold) {
     status.nmi_line = false;
   }
   return result;
@@ -105,25 +83,25 @@ bool sCPU::rdnmi() {
 
 bool sCPU::timeup() {
   bool result = status.irq_line;
-  if(counter.irq_hold == 0) {
+  if(!status.irq_hold) {
     status.irq_line = false;
     status.irq_transition = false;
   }
   return result;
 }
 
-alwaysinline bool sCPU::nmi_test() {
-  if(status.nmi_transition == false) return false;
+bool sCPU::nmi_test() {
+  if(!status.nmi_transition) return false;
   status.nmi_transition = false;
-  event.wai = false;
+  status.wai_lock = false;
   return true;
 }
 
-alwaysinline bool sCPU::irq_test() {
-  if(status.irq_transition == false) return false;
+bool sCPU::irq_test() {
+  if(!status.irq_transition) return false;
   status.irq_transition = false;
-  event.wai = false;
+  status.wai_lock = false;
   return !regs.p.i;
 }
 
-#endif  //ifdef SCPU_CPP
+#endif

src/cpu/scpu/timing/joypad.cpp

@@ -25,4 +25,4 @@ void sCPU::run_auto_joypad_poll() {
   status.joy4h = joy4 >> 8;
 }
 
-#endif  //ifdef SCPU_CPP
+#endif

src/cpu/scpu/timing/timing.cpp

@@ -1,89 +1,80 @@
 #ifdef SCPU_CPP
 
+#include "event.cpp"
 #include "irq.cpp"
 #include "joypad.cpp"
 
 unsigned sCPU::dma_counter() {
-  return (status.dma_counter + ppucounter.hcounter()) & 7;
+  return (status.dma_counter + ppu.hcounter()) & 7;
 }
 
 void sCPU::add_clocks(unsigned clocks) {
-  if(status.dram_refreshed == false) {
-    if(ppucounter.hcounter() + clocks >= status.dram_refresh_position) {
-      status.dram_refreshed = true;
-      clocks += 40;
-    }
-  }
-
-  counter.sub(counter.irq_delay, clocks);
+  event.tick(clocks);
   unsigned ticks = clocks >> 1;
   while(ticks--) {
-    ppucounter.tick();
-    snes.input.tick();
-    poll_interrupts();
+    ppu.tick();
+    if((ppu.hcounter() & 2) == 0) {
+      snes.input.tick();
+    } else {
+      poll_interrupts();
+    }
   }
-
   scheduler.addclocks_cpu(clocks);
 }
 
 void sCPU::scanline() {
   status.dma_counter = (status.dma_counter + status.line_clocks) & 7;
-  status.line_clocks = ppucounter.lineclocks();
-  if(ppucounter.vcounter() == 0) frame();
+  status.line_clocks = ppu.lineclocks();
+
+  if(ppu.vcounter() == 0) {
+    //hdma init triggers once every frame
+    event.enqueue(cpu_version == 1 ? 12 + 8 - dma_counter() : 12 + dma_counter(), EventHdmaInit);
+  }
 
   //dram refresh occurs once every scanline
-  status.dram_refreshed = false;
   if(cpu_version == 2) status.dram_refresh_position = 530 + 8 - dma_counter();
+  event.enqueue(status.dram_refresh_position, EventDramRefresh);
 
   //hdma triggers once every visible scanline
-  status.hdma_triggered = (ppucounter.vcounter() <= (ppu.overscan() == false ? 224 : 239)) ? false : true;
+  if(ppu.vcounter() <= (ppu.overscan() == false ? 224 : 239)) {
+    event.enqueue(1104, EventHdmaRun);
+  }
 
-  update_interrupts();
-
-  if(status.auto_joypad_poll == true && ppucounter.vcounter() == (ppu.overscan() == false ? 227 : 242)) {
+  if(status.auto_joypad_poll == true && ppu.vcounter() == (ppu.overscan() == false ? 227 : 242)) {
     snes.input.poll();
     run_auto_joypad_poll();
   }
 }
 
-void sCPU::frame() {
-  status.hdmainit_triggered = false;
-  if(cpu_version == 1) {
-    status.hdmainit_trigger_position = 12 + 8 - dma_counter();
-  } else {
-    status.hdmainit_trigger_position = 12 + dma_counter();
-  }
-}
-
 //used for H/DMA bus synchronization
 void sCPU::precycle_edge() {
-  if(status.dma_state == DMA_CPUsync) {
+  if(status.dma_state == DmaCpuSync) {
     add_clocks(status.clock_count - (status.dma_clocks % status.clock_count));
-    status.dma_state = DMA_Inactive;
+    status.dma_state = DmaInactive;
   }
 }
 
 //used to test for H/DMA, which can trigger on the edge of every opcode cycle.
 void sCPU::cycle_edge() {
-  if(status.hdmainit_triggered == false) {
-    if(ppucounter.hcounter() >= status.hdmainit_trigger_position || ppucounter.vcounter()) {
-      status.hdmainit_triggered = true;
-      hdma_init_reset();
-      if(hdma_enabled_channels()) {
-        status.hdma_pending = true;
-        status.hdma_mode = 0;
-      }
-    }
-  }
+  while(cycle_edge_state) {
+    switch(bit::lowest(cycle_edge_state)) {
+      case EventFlagHdmaInit: {
+        hdma_init_reset();
+        if(hdma_enabled_channels()) {
+          status.hdma_pending = true;
+          status.hdma_mode = 0;
+        }
+      } break;
 
-  if(status.hdma_triggered == false) {
-    if(ppucounter.hcounter() >= 1104) {
-      status.hdma_triggered = true;
-      if(hdma_active_channels()) {
-        status.hdma_pending = true;
-        status.hdma_mode = 1;
-      }
+      case EventFlagHdmaRun: {
+        if(hdma_active_channels()) {
+          status.hdma_pending = true;
+          status.hdma_mode = 1;
+        }
+      } break;
     }
+
+    cycle_edge_state = bit::clear_lowest(cycle_edge_state);
   }
 
   //H/DMA pending && DMA inactive?
@@ -94,30 +85,30 @@ void sCPU::cycle_edge() {
   //.. Run one bus CPU cycle
   //.. CPU sync
 
-  if(status.dma_state == DMA_Run) {
+  if(status.dma_state == DmaRun) {
     if(status.hdma_pending) {
       status.hdma_pending = false;
       if(hdma_enabled_channels()) {
-        dma_add_clocks(8 - dma_counter()); //DMA sync
+        dma_add_clocks(8 - dma_counter());  //DMA sync
         status.hdma_mode == 0 ? hdma_init() : hdma_run();
-        if(!dma_enabled_channels()) status.dma_state = DMA_CPUsync;
+        if(!dma_enabled_channels()) status.dma_state = DmaCpuSync;
       }
     }
 
     if(status.dma_pending) {
       status.dma_pending = false;
       if(dma_enabled_channels()) {
-        dma_add_clocks(8 - dma_counter()); //DMA sync
+        dma_add_clocks(8 - dma_counter());  //DMA sync
         dma_run();
-        status.dma_state = DMA_CPUsync;
+        status.dma_state = DmaCpuSync;
       }
     }
   }
 
-  if(status.dma_state == DMA_Inactive) {
+  if(status.dma_state == DmaInactive) {
     if(status.dma_pending || status.hdma_pending) {
       status.dma_clocks = 0;
-      status.dma_state = DMA_Run;
+      status.dma_state = DmaRun;
     }
   }
 }
@@ -125,62 +116,51 @@ void sCPU::cycle_edge() {
 //used to test for NMI/IRQ, which can trigger on the edge of every opcode.
 //test one cycle early to simulate two-stage pipeline of x816 CPU.
 //
-//status.irq_delay is used to simulate hardware delay before interrupts can
+//status.irq_lock is used to simulate hardware delay before interrupts can
 //trigger during certain events (immediately after DMA, writes to $4200, etc)
 void sCPU::last_cycle() {
-  if(counter.irq_delay) return;
+  if(!status.irq_lock) {
+    status.nmi_pending |= nmi_test();
+    status.irq_pending |= irq_test();
 
-  status.nmi_pending |= nmi_test();
-  status.irq_pending |= irq_test();
-
-  event.irq = (status.nmi_pending || status.irq_pending);
+    status.interrupt_pending = (status.nmi_pending || status.irq_pending);
+  }
 }
 
 void sCPU::timing_power() {
 }
 
 void sCPU::timing_reset() {
-  counter.nmi_hold  = 0;
-  counter.irq_hold  = 0;
-
-  counter.nmi_fire  = 0;
-  counter.irq_fire  = 0;
-  counter.irq_delay = 0;
-  counter.hw_math   = 0;
+  event.reset();
 
   status.clock_count = 0;
-  status.line_clocks = ppucounter.lineclocks();
+  status.line_clocks = ppu.lineclocks();
 
-  status.dram_refreshed = false;
-  status.dram_refresh_position = (cpu_version == 1) ? 530 : 538;
-
-  status.hdmainit_triggered = false;
-  status.hdmainit_trigger_position = 0;
-
-  status.hdma_triggered = false;
-
-  status.irq_delay = 0;
+  status.irq_lock = false;
+  status.alu_lock = false;
+  status.dram_refresh_position = (cpu_version == 1 ? 530 : 538);
+  event.enqueue(status.dram_refresh_position, EventDramRefresh);
 
   status.nmi_valid      = false;
   status.nmi_line       = false;
   status.nmi_transition = false;
   status.nmi_pending    = false;
+  status.nmi_hold       = false;
 
   status.irq_valid      = false;
   status.irq_line       = false;
   status.irq_transition = false;
   status.irq_pending    = false;
-
-  update_interrupts();
+  status.irq_hold       = false;
 
   status.dma_counter  = 0;
   status.dma_clocks   = 0;
   status.dma_pending  = false;
   status.hdma_pending = false;
   status.hdma_mode    = 0;
-  status.dma_state    = DMA_Inactive;
+  status.dma_state    = DmaInactive;
+
+  cycle_edge_state = 0;
 }
 
-#undef ntsc_color_burst_phase_shift_scanline
-
-#endif  //ifdef SCPU_CPP
+#endif

src/cpu/scpu/timing/timing.hpp

@@ -1,27 +1,41 @@
+  enum {
+    EventNone,
+    EventIrqLockRelease,
+    EventAluLockRelease,
+    EventDramRefresh,
+    EventHdmaInit,
+    EventHdmaRun,
+
+    //cycle edge
+    EventFlagHdmaInit = 1 << 0,
+    EventFlagHdmaRun  = 1 << 1,
+  };
+  unsigned cycle_edge_state;
+
   //timing.cpp
   unsigned dma_counter();
 
   void add_clocks(unsigned clocks);
   void scanline();
-  void frame();
 
-  void precycle_edge();
-  void cycle_edge();
+  alwaysinline void precycle_edge();
+  alwaysinline void cycle_edge();
   void last_cycle();
 
   void timing_power();
   void timing_reset();
 
   //irq.cpp
-  void update_interrupts();
-  void poll_interrupts();
+  alwaysinline void poll_interrupts();
   void nmitimen_update(uint8 data);
-  void hvtime_update(uint16 addr);
   bool rdnmi();
   bool timeup();
 
-  bool nmi_test();
-  bool irq_test();
+  alwaysinline bool nmi_test();
+  alwaysinline bool irq_test();
 
   //joypad.cpp
   void run_auto_joypad_poll();
+
+  //event.cpp
+  void queue_event(unsigned);  //priorityqueue callback function

src/data/bsnes.desktop

@@ -0,0 +1,8 @@
+[Desktop Entry]
+Name=bsnes
+Comment=SNES emulator
+Exec=bsnes
+Icon=bsnes
+Terminal=false
+Type=Application
+Categories=Game;Emulator;

src/data/documentation.html

@@ -0,0 +1,81 @@
+<!DOCTYPE html>
+<html>
+<head></head>
+<body>
+
+<h1>bsnes&trade; Usage Documentation</h1><br>
+
+bsnes is a Super Nintendo / Super Famicom emulator that strives to provide
+the most faithful emulation experience possible. It focuses on accuracy and
+clean code; over speed and features.
+<hr>
+
+<h2><u>Modes of Operation</u></h2><br>
+
+bsnes is capable of running both in its default multi-user mode, as well as
+in single-user mode.<br>
+<br>
+
+In multi-user mode, configuration data is stored inside the user's home
+directory. On Windows, this is located at "%APPDATA%/.bsnes". On other operating
+systems, this is located at "~/.bsnes".<br>
+<br>
+
+To enable single-user mode, create a blank "bsnes.cfg" file inside the same
+folder as the bsnes executable. bsnes will then use this file to store
+configuration data.
+<hr>
+
+<h2><u>Supported Filetypes</u></h2><br>
+
+<b>SFC, SMC, SWC, FIG:</b> SNES cartridge &mdash; ROM image.<br>
+<b>BS:</b> Satellaview BS-X flash cartridge &mdash; EEPROM image.<br>
+<b>ST:</b> Sufami Turbo cartridge &mdash; ROM image.<br>
+<b>SRM, PSR:</b> non-volatile memory, often used to save game data &mdash; (P)SRAM image.<br>
+<b>RTC:</b> real-time clock non-volatile memory.<br>
+<b>UPS:</b> patch data, used to dynamically modify cartridge of same base filename upon load.<br>
+<b>CHT:</b> plain-text list of "Game Genie" / "Pro Action Replay" codes.
+<hr>
+
+<h2><u>Known Limitations</u></h2><br>
+
+<b>Cartridge co-processors:</b> certain cartridges contain special co-processor chips to enhance
+their functionality. Some of these are either partially or completely unsupported. A message box
+warning will pop up when attempting to load such a cartridge.<br>
+<br>
+
+<b>Satellaview BS-X emulation:</b> this hardware is only partially supported. As a result,
+most BS-X software will not function correctly.<br>
+<br>
+
+<b>Savestates:</b> due to the design of bsnes, it is not plausible to
+implement support for savestate and/or rewind functionality.<br>
+<br>
+
+<b>Netplay:</b> internet multiplay is not currently supported nor planned.
+<hr>
+
+<h2><u>Contributors</u></h2>
+&bull; Andreas Naive<br>
+&bull; anomie<br>
+&bull; Derrick Sobodash<br>
+&bull; DMV27<br>
+&bull; FirebrandX<br>
+&bull; FitzRoy<br>
+&bull; GIGO<br>
+&bull; Jonas Quinn<br>
+&bull; kode54<br>
+&bull; krom<br>
+&bull; Matthew Callis<br>
+&bull; Nach<br>
+&bull; neviksti<br>
+&bull; Overload<br>
+&bull; RedDwarf<br>
+&bull; Richard Bannister<br>
+&bull; Shay Green<br>
+&bull; tetsuo55<br>
+&bull; TRAC<br>
+&bull; zones<br>
+
+</body>
+</html>

src/data/icon48.h

@@ -1,41 +0,0 @@
-static char enc_icon48[] = {
-  "_gAB8AHwAfAB8AHwAfAB8P8B8AHwAfAB8AHwAfAB8AHw_wHwAfAB8AHwAfAB8AHw"
-  "AfD_AfAB8AHwAfAB8AHwAfAB8P8B8AHwAfAB8AHwAfAB8AHw_wHwAfAB8AHwAfAB"
-  "8AHwAfD_AfAB8AHwAfAB8AHwAfAB8P8B8AHwAfAB8AHwAfAB8AHw_wHwAfAB8AHw"
-  "AfAB8AHwAfD_AfAB8AHwAfAB8AHwAfABAAD_qgAD_p8VOwD_oRaI_qEWthD-oBbL"
-  "CADE_qEAFaP_oBZm_p38GBU28AHwAfAB8AHwAfBfAfAB8AFQuBCoAMe0AP4twAD_"
-  "BPAEIPAkAIX_-JkZCkLwAfAB8AHwAfBHAfAB8HSB_wABtABvPQQA-7DwBPAEECwA"
-  "0P74oBIbTvAB8AHwAfAB8EcB8AHweEGgFWwkAv0HqPAE8MSwFdX-oRr-E1LwAfAB"
-  "8AHwAfAB8Lzg6KEUMRAC96DwBPAE8P3EIKXAEVrwAfAB8AHwAfDzAfDAsBa3mPAE"
-  "8ATwwED_uAE4E1rwAfAB8AHwAfAB8PG8YKIVJDjyBPAE8ATA-KAWoF7wAfAB8AHw"
-  "AfB7AfD4gmmQ8ATwBPDM4-Z_XvAB8AHwAfAB8AHwwICPH_wSePQE8ATwBMClDxEB"
-  "YNBERP8PPz_-oEw-Pv56CACMCACCgggAXT8__yD2BA808wHwAfDAkKMSDv6AmxwS"
-  "_qQYH8QC6kjIAJTUAOug8ATwhOFDRABYUDw8_hWsAI9QPj7_8KwA_wTw_oL6BAC1"
-  "PT3-MpbwjwHwAfAB8AxmpRkUFAOOkxjzBPAEoJ8PEEAQdZQAOrwA47TwBPAoAPh9"
-  "yAB0hvAB8AHwAfBcsha6XFwC-KzwBPDsAOQ0EHWQAD0EAPSs8ATwBMCAn4LwAfAB"
-  "8AHwXLUVakz4gwTwKACbQkL-F0wBTuac8ATwiPH-_AQATh-C8AHwAfAB8ExifwAC"
-  "DcAAtbTwfKT8_qETejSAAJOc8ATwBPAUY9p9CAAIhvAB8AHwAfCEYZ4MGDWE8YCn"
-  "nEs8_3oRgAD1lPAE8ATwBKBVh4LwAQAUCwDNACQEAKBNAMwAaggAewgAoH8AywBz"
-  "CABbCABgNwDIAA458Nxp2IO88Hwhzf-ZEQ-0A15XjPAE8ATwhOGlfaDOVAA1oACY"
-  "sADhCAD9jQgA_wTwBEDMAPQEAHq7NABjCAAcq2QRvPAW9sUMXHwAiIzwBPAE8MDg"
-  "otZxIMsAGYQArQQATv6s8ATwzPAA4wQAUVcKAGQmYAR9MILpBAB3sP-qKgbgUPwC"
-  "mwQAevuAAP6U8ATwBPDAYO3QANEAHIQA3JjwBPCrBPAEoPwEAGyAQVRwAeCV_qIX"
-  "WPQWZNJ8AKoQgAQbSAI2hABtzAC6xAgA_aDwBPCIxOc4Ab6mjPAE8ATwBPAEAPYE"
-  "AK9YZwHwAfA2QwLAAEgEAK7dqPAE8MCAx8AA5Ijw_wTwBPAE8ExCFPQB8AHwAQDQ"
-  "Q0P-E5QAw6zwBPD1wECLcAC2iPAE8ATwBPD1BAD70AMqmvAB8AHwATDQODj-EpgA"
-  "1LDwxPbFBAAxcCDNAOyM8ATwewTwBOCGkvAB8AHwIOM8t-AzuPC8g66UasQwyJDw"
-  "VwTwBPAEIPHEBG4KAAJBDcYKAP7-LAQAT1UEAGUEAHAEAGoEAFd1BAA5BAASJAAY"
-  "-8Qg_gaytPB8Yeg7O_8eUTGgvwAEyABUUAK3XZAA9aTw6OJsFdgIAIOQAM8AG_11"
-  "_guUAKpgCAC1BADvDAD_BPAxBED-_vgIAEoA_nzDBAD4o0BA_lO88Lwgjuy4FPLw"
-  "AYDPABCYAKpCoABtBACKBACbEACKngQAk4wnzQBXoCd3qBe5plgh4azwBPDM8P76"
-  "9QQAiwwA1CjgGeQSvMD6yAQAKbHwAfAB8AHwvMC9RBH-nPAE8ATwBKDAxCFVVDXu"
-  "sADzCAC9dEgEX3nwAfAB8AHwvMAxBAD8X4zwBPAE8ATwTAB-3Ewh_bQADHHwAfAB"
-  "8AHwAfDAYL50iPAE8ATwBPDAQMRl8L8B8AHwAfAB8AHwcABMiPDvBPAE8ATwwECc"
-  "ZfAB8AHwrwHwAfAB8HQAAnQAsIzw9wTwBPC84OQIABy1AfAB8O8B8AHwAfDs1ZUI"
-  "8wTwBPD1vGDHBAAkXfAB8AHwAfCnAfAB8Mjw_zCEAJ8EAK7rpPAE8CgA9wQAvAQA"
-  "_lQQAJC1AfAB8AHwAfAB8FcB8MjwkBE6BABsBACPVQQApAQArwQAqQQAl_UgAHgI"
-  "AEsEANQsAfAB8P8B8AHwAfAB8AHwAfAB8AHw_wHwAfAB8AHwAfAB8AHwAfD_AfAB"
-  "8AHwAfAB8AHwAfAB8P8B8AHwAfAB8AHwAfAB8AHw_wHwAfAB8AHwAfAB8AHwAfD_"
-  "AfAB8AHwAfAB8AHwAfAB8P8B8AHwAfAB8AHwAfAB8AHw_wHwAfAB8AHwAfAB8AHw"
-  "AfD_AfAB8AHwAfAB8AHwAfAB8A8B8AHwAfABsA"
-};

src/data/license.html

@@ -0,0 +1,87 @@
+<!DOCTYPE html>
+<html>
+<head></head>
+<body>
+
+<h1>bsnes&trade; Reference License</h1><br>
+<b>Copyright &copy; 2004&ndash;2009 byuu<br>
+All rights reserved</b>
+<hr>
+
+<h2><u>1. Definitions</u></h2><br>
+
+The terms "reproduce", "reproduction", "distribute" and "distribution" have the
+same meaning here as under U.S. copyright law.<br><br>
+
+"The software" means this software package as a whole, including, but not
+limited to, this license, binaries, source code, documentation, and data.<br><br>
+
+"You" means the licensee of the software.<br><br>
+
+"The licensor" means the copyright holder of the software, byuu.
+<hr>
+
+<h2><u>2. Grant of Rights</u></h2><br>
+
+Subject to the terms of this license, the licensor grants you a
+non-transferable, non-exclusive, worldwide, royalty-free copyright license to
+reproduce the software for non-commercial use only, provided the software
+remains unmodified, and there is no charge for the software itself, nor for the
+medium upon which the software is distributed. The reproduction of modified or
+derivative works of the software is strictly prohibited without the express
+consent of the licensor.
+<hr>
+
+<h2><u>3. Limitations</u></h2><br>
+
+This license does not grant you any rights to use the licensor's name, logo or
+trademarks.<br>
+<br>
+
+The software is provided "as is", and any express or implied warranties,
+including, but not limited to, the implied warranties of merchantability and
+fitness for a particular purpose are disclaimed. In no event shall the licensor
+be liable for any direct, indirect, incidental, special, exemplary, or
+consequential damages (including, but not limited to, procurement of sbustitute
+goods or services; loss of use, data, or profits; or business interruption)
+however caused and on any theory of liability, whether in contract, strict
+liability, or tort (including negligence or otherwise) arising in any way out of
+the use of the software, even if advised of the possibility of such damage.<br>
+<br>
+
+In the event that this license is determined to be invalid or unenforceable, the
+Grant of Rights will become null and void, and no rights shall be granted to the
+licensee, within the scope of U.S. copyright law.
+<hr>
+
+<h2><u>4. Exemptions</u></h2><br>
+
+The software includes the work of other copyrights holders, which is licensed
+under different agreements, and exempt from this license. Below is a complete
+list of all such software, and their respective copyright holders and licenses.
+Note that explicit permission has been granted to the licensor to use included
+software which is ordinarily not compatible with this license, such as the GPL.
+<br>
+
+<table border="1" cellpadding="3">
+  <tr><td><b>Name</b></td><td><b>License</b></td><td><b>Author(s)</b></td></tr>
+
+  <tr><td>Cx4 emulator</td><td></td><td>anomie, Kris Bleakley, Nach, zsKnight</td></tr>
+  <tr><td>DSP-1 emulator</td><td></td><td>Andreas Naive, John Weidman, Kris Bleakley, neviksti</td></tr>
+  <tr><td>DSP-2 emulator</td><td></td><td>Kris Bleakley</td></tr>
+  <tr><td>DSP-3 emulator</td><td></td><td>John Weidman, Kris Bleakley, Lancer, z80 gaiden</td></tr>
+  <tr><td>DSP-4 emulator</td><td></td><td>Dreamer Nom, John Weidman, Kris Bleakley, Nach, z80 gaiden</td></tr>
+  <tr><td>S-DD1 decompressor</td><td>Public Domain</td><td>Andreas Naive</td></tr>
+  <tr><td>S-DSP emulator</td><td>LGPL 2.1</td><td>Shay Green</td></tr>
+  <tr><td>SPC7110 decompressor</td><td>Public Domain</td><td>neviksti</td></tr>
+  <tr><td>ST-0010 emulator</td><td></td><td>Feather, John Weidman, Kris Bleakley, Matthew Kendora</td></tr>
+
+  <tr><td>Qt toolkit</td><td>LGPL 2.1</td><td>Nokia</td></tr>
+  <tr><td>HQ2x filter</td><td>LGPL 2.1</td><td>MaxST</td></tr>
+  <tr><td>JMA decompressor</td><td>GPL 2</td><td>NSRT team</td></tr>
+  <tr><td>NTSC filter</td><td>LGPL 2.1</td><td>Shay Green</td></tr>
+  <tr><td>zlib decompressor</td><td>zlib license</td><td>zlib team</td></tr>
+</table>
+
+</body>
+</html>

src/interface.hpp

@@ -1,24 +1,20 @@
-#include "reader/reader.hpp"
 #include "cheat/cheat.hpp"
-#include "config/config.hpp"
 
 #include "memory/memory.hpp"
 #include "memory/smemory/smemory.hpp"
 
-#include "cart/cart.hpp"
-
 #include "cpu/cpu.hpp"
 #include "cpu/scpu/scpu.hpp"
 
+#include "ppu/ppu.hpp"
+#include "ppu/bppu/bppu.hpp"
+
 #include "smp/smp.hpp"
 #include "smp/ssmp/ssmp.hpp"
 
 #include "dsp/dsp.hpp"
 #include "dsp/sdsp/sdsp.hpp"
 
-#include "ppu/ppu.hpp"
-#include "ppu/bppu/bppu.hpp"
-
 extern BUSCORE bus;
 extern CPUCORE cpu;
 extern SMPCORE smp;
@@ -26,4 +22,3 @@ extern DSPCORE dsp;
 extern PPUCORE ppu;
 
 #include "snes/snes.hpp"
-#include "chip/chip.hpp"

src/lib/hiro/gtk/hiro.cpp

@@ -131,15 +131,15 @@ bool pHiro::file_open(Window *focus, char *filename, const char *path, const cha
 
   if(filter && *filter) {
     lstring filterlist;
-    split(filterlist, "\n", filter);
-    for(unsigned i = 0; i < count(filterlist); i++) {
+    filterlist.split("\n", filter);
+    for(unsigned i = 0; i < filterlist.size(); i++) {
       GtkFileFilter *filter = gtk_file_filter_new();
       lstring filterpart;
-      split(filterpart, "\t", filterlist[i]);
+      filterpart.split("\t", filterlist[i]);
       gtk_file_filter_set_name(filter, string() << filterpart[0] << " (" << filterpart[1] << ")");
       lstring patternlist;
-      split(patternlist, ",", filterpart[1]);
-      for(unsigned l = 0; l < count(patternlist); l++) {
+      patternlist.split(",", filterpart[1]);
+      for(unsigned l = 0; l < patternlist.size(); l++) {
         gtk_file_filter_add_pattern(filter, patternlist[l]);
       }
       gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
@@ -174,15 +174,15 @@ bool pHiro::file_save(Window *focus, char *filename, const char *path, const cha
 
   if(filter && *filter) {
     lstring filterlist;
-    split(filterlist, "\n", filter);
-    for(unsigned i = 0; i < count(filterlist); i++) {
+    filterlist.split("\n", filter);
+    for(unsigned i = 0; i < filterlist.size(); i++) {
       GtkFileFilter *filter = gtk_file_filter_new();
       lstring filterpart;
-      split(filterpart, "\t", filterlist[i]);
+      filterpart.split("\t", filterlist[i]);
       gtk_file_filter_set_name(filter, string() << filterpart[0] << " (" << filterpart[1] << ")");
       lstring patternlist;
-      split(patternlist, ",", filterpart[1]);
-      for(unsigned l = 0; l < count(patternlist); l++) {
+      patternlist.split(",", filterpart[1]);
+      for(unsigned l = 0; l < patternlist.size(); l++) {
         gtk_file_filter_add_pattern(filter, patternlist[l]);
       }
       gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);

src/lib/hiro/gtk/listbox.cpp

@@ -29,11 +29,11 @@ void pListbox::create(unsigned style, unsigned width, unsigned height, const cha
   gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollbox), GTK_SHADOW_ETCHED_IN);
 
   lstring list;
-  split(list, "\t", columns);
+  list.split("\t", columns);
 
-  GType *v = (GType*)malloc(count(list) * sizeof(GType));
-  for(unsigned i = 0; i < count(list); i++) v[i] = G_TYPE_STRING;
-  store = gtk_list_store_newv(count(list), v);
+  GType *v = (GType*)malloc(list.size() * sizeof(GType));
+  for(unsigned i = 0; i < list.size(); i++) v[i] = G_TYPE_STRING;
+  store = gtk_list_store_newv(list.size(), v);
   free(v);
 
   listbox = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
@@ -44,8 +44,8 @@ void pListbox::create(unsigned style, unsigned width, unsigned height, const cha
   gtk_widget_show(scrollbox);
 
   //alternate colors for each listbox entry if there are multiple columns
-  gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(listbox), count(list) >= 2 ? true : false);
-  for(unsigned i = 0; i < count(list); i++) {
+  gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(listbox), list.size() >= 2 ? true : false);
+  for(unsigned i = 0; i < list.size(); i++) {
     unsigned i = column.size();
     column[i].renderer = gtk_cell_renderer_text_new();
     column[i].column = gtk_tree_view_column_new_with_attributes(
@@ -61,8 +61,8 @@ void pListbox::create(unsigned style, unsigned width, unsigned height, const cha
   }
 
   if(text && *text) {
-    split(list, "\n", text);
-    for(unsigned i = 0; i < count(list); i++) add_item(list[i]);
+    list.split("\n", text);
+    for(unsigned i = 0; i < list.size(); i++) add_item(list[i]);
   }
 
   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(listbox), header);
@@ -85,9 +85,9 @@ void pListbox::set_column_width(unsigned index, unsigned width) {
 
 void pListbox::add_item(const char *text) {
   lstring list;
-  split(list, "\t", text);
+  list.split("\t", text);
   gtk_list_store_append(store, &iter);
-  for(unsigned i = 0; i < count(list); i++) {
+  for(unsigned i = 0; i < list.size(); i++) {
     gtk_list_store_set(store, &iter, i, (const char*)list[i], -1);
   }
 }
@@ -101,8 +101,8 @@ void pListbox::set_item(unsigned index, const char *text) {
   }
 
   lstring list;
-  split(list, "\t", text);
-  for(unsigned i = 0; i < count(list); i++) {
+  list.split("\t", text);
+  for(unsigned i = 0; i < list.size(); i++) {
     gtk_list_store_set(store, &iter, i, (const char*)list[i], -1);
   }
 }

src/lib/hiro/win/editbox.cpp

@@ -8,6 +8,8 @@ void pEditbox::create(unsigned style, unsigned width, unsigned height, const cha
                      (style & Editbox::HorizontalScrollNever ) ? 0 :
                      ES_AUTOHSCROLL;
 
+  autovscroll = (vscroll == ES_AUTOVSCROLL);
+
   hwnd = CreateWindowEx(WS_EX_CLIENTEDGE, L"EDIT", L"",
     WS_CHILD | WS_VISIBLE | vscroll | hscroll |
     (multiline == true ? ES_MULTILINE | ES_WANTRETURN : WS_TABSTOP) |
@@ -16,13 +18,20 @@ void pEditbox::create(unsigned style, unsigned width, unsigned height, const cha
     phiro().default_hwnd, (HMENU)instance, GetModuleHandle(0), 0);
   SendMessage(hwnd, WM_SETFONT, (WPARAM)phiro().default_font, 0);
   set_text(text);
+  update();
+}
+
+void pEditbox::resize(unsigned width, unsigned height) {
+  pFormControl::resize(width, height);
+  update();
 }
 
 void pEditbox::set_text(const char *text) {
   string temp = text ? text : "";
-  replace(temp, "\r", "");
-  replace(temp, "\n", "\r\n");
+  temp.replace("\r", "");
+  temp.replace("\n", "\r\n");
   SetWindowText(hwnd, utf16(temp));
+  update();
 }
 
 unsigned pEditbox::get_text(char *text, unsigned length) {
@@ -30,10 +39,46 @@ unsigned pEditbox::get_text(char *text, unsigned length) {
   GetWindowText(hwnd, buffer, length);
   string temp = (const char*)utf8(buffer);
   delete[] buffer;
-  replace(temp, "\r", "");
+  temp.replace("\r", "");
   strlcpy(text, temp, length);
   return strlen(text);
 }
 
 pEditbox::pEditbox(Editbox &self_) : pFormControl(self_), self(self_) {
+  autovscroll = false;
+}
+
+//========
+//internal
+//========
+
+//WS_VSCROLL always shows the scrollbar;
+//ES_AUTOVSCROLL never shows the scrollbar but allows unlimited text;
+//no style disallows more text than what fits in the window.
+//
+//below routine simulates the effect of allowing unlimited text, but only
+//showing the scrollbar when it is needed. not sure how to simulate this effect
+//for horizontal scrolling at this time.
+//
+//below routine should be called whenever the font, text or window size is
+//modified.
+void pEditbox::update() {
+  if(autovscroll == true) {
+    //determine how many lines of text this control allows
+    RECT rect;
+    SendMessage(hwnd, EM_GETRECT, 0, (LPARAM)&rect);
+    unsigned height = rect.bottom - rect.top;
+
+    //determine the height of a single line of text
+    HDC hdc = GetDC(hwnd);
+    SelectObject(hdc, phiro().default_font);
+    DrawText(hdc, L"byuu", -1, &rect, DT_CALCRECT);
+    ReleaseDC(hwnd, hdc);
+    unsigned lineheight = rect.bottom - rect.top;
+
+    //only show the scrollbar when there are more lines of text
+    //than the control can show at once.
+    unsigned linecount = SendMessage(hwnd, EM_GETLINECOUNT, 0, 0);
+    ShowScrollBar(hwnd, SB_VERT, linecount > (height / lineheight));
+  }
 }

src/lib/hiro/win/editbox.hpp

@@ -2,8 +2,13 @@ class pEditbox : public pFormControl {
 public:
   Editbox &self;
   void create(unsigned style, unsigned width, unsigned height, const char *text = "");
+  void resize(unsigned width, unsigned height);
   unsigned get_text(char *text, unsigned length = -1U);
   void set_text(const char *text = "");
 
   pEditbox(Editbox&);
+
+//private:
+  bool autovscroll;
+  void update();
 };

src/lib/hiro/win/hiro.cpp

@@ -106,23 +106,22 @@ bool pHiro::folder_select(Window *focus, char *filename, const char *path) {
 
 bool pHiro::file_open(Window *focus, char *filename, const char *path, const char *filter) {
   string dir, f;
-  strcpy(dir, path ? path : "");
-  replace(dir, "/", "\\");
+  dir = path ? path : "";
+  dir.replace("/", "\\");
 
   lstring type, part;
-  strcpy(f, "");
-  split(type, "\n", filter);
-  for(int i = 0; i < count(type); i++) {
-    split(part, "\t", type[i]);
-    if(count(part) != 2) continue;
+  type.split("\n", filter);
+  for(int i = 0; i < type.size(); i++) {
+    part.split("\t", type[i]);
+    if(part.size() != 2) continue;
 
-    strcat(f, part[0]);
-    strcat(f, " (");
-    strcat(f, part[1]);
-    strcat(f, ")\t");
-    replace(part[1], ",", ";");
-    strcat(f, part[1]);
-    strcat(f, "\t");
+    f.append(part[0]);
+    f.append(" (");
+    f.append(part[1]);
+    f.append(")\t");
+    part[1].replace(",", ";");
+    f.append(part[1]);
+    f.append("\t");
   }
 
   utf16 wfilter(f);
@@ -154,23 +153,22 @@ bool pHiro::file_open(Window *focus, char *filename, const char *path, const cha
 
 bool pHiro::file_save(Window *focus, char *filename, const char *path, const char *filter) {
   string dir, f;
-  strcpy(dir, path ? path : "");
-  replace(dir, "/", "\\");
+  dir = path ? path : "";
+  dir.replace("/", "\\");
 
   lstring type, part;
-  strcpy(f, "");
-  split(type, "\n", filter);
-  for(int i = 0; i < count(type); i++) {
-    split(part, "\t", type[i]);
-    if(count(part) != 2) continue;
+  type.split("\n", filter);
+  for(int i = 0; i < type.size(); i++) {
+    part.split("\t", type[i]);
+    if(part.size() != 2) continue;
 
-    strcat(f, part[0]);
-    strcat(f, " (");
-    strcat(f, part[1]);
-    strcat(f, ")\t");
-    replace(part[1], ",", ";");
-    strcat(f, part[1]);
-    strcat(f, "\t");
+    f.append(part[0]);
+    f.append(" (");
+    f.append(part[1]);
+    f.append(")\t");
+    part[1].replace(",", ";");
+    f.append(part[1]);
+    f.append("\t");
   }
 
   utf16 wfilter(f);
@@ -232,7 +230,7 @@ pHiro& phiro() {
 
 HFONT pHiro::create_font(const char *name, unsigned size) {
   return CreateFont(
-    -(size * 96.0 / 72.0 + 0.5), //96 = DPI
+    -(size * 96.0 / 72.0 + 0.5),  //96 = DPI
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     utf16(name)
   );
@@ -375,6 +373,7 @@ LRESULT pHiro::wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
         case Widget::EditboxType: {
           Editbox &editbox = (Editbox&)*widget;
           if(HIWORD(wparam) == EN_CHANGE) {
+            editbox.p.update();  //called to dynamically display vertical scrollbar if needed
             if(editbox.on_change) editbox.on_change(event_t(event_t::Change, 0, &editbox));
           }
         } break;

src/lib/hiro/win/hiro.hpp

@@ -13,20 +13,22 @@
 #define NOMINMAX
 #define _NO_OLDNAMES
 
+#define mkdir _mkdir
 #define UNICODE
 #include <windows.h>
 #include <commctrl.h>
 #include <io.h>
 #include <direct.h>
 #include <shlobj.h>
+#undef mkdir
 
 #include <nall/algorithm.hpp>
 using nall::min;
 using nall::max;
 
 #include <nall/utf8.hpp>
-using nall::utf8;
-using nall::utf16;
+#define utf8  nall::utf8_t
+#define utf16 nall::utf16_t
 
 extern int hiromain(int argc, const char *const argv[]);
 

src/lib/hiro/win/listbox.cpp

@@ -16,21 +16,21 @@ void pListbox::create(unsigned style, unsigned width, unsigned height, const cha
   ListView_SetExtendedListViewStyle(hwnd, LVS_EX_FULLROWSELECT);
 
   lstring list;
-  split(list, "\t", columns ? columns : "");
-  column_count = count(list);
-  for(unsigned i = 0; i < count(list); i++) {
+  list.split("\t", columns ? columns : "");
+  column_count = list.size();
+  for(unsigned i = 0; i < list.size(); i++) {
     LVCOLUMN column;
     column.mask = LVCF_FMT | LVCF_TEXT | LVCF_SUBITEM;
     column.fmt = LVCFMT_LEFT;
-    column.iSubItem = count(list);
+    column.iSubItem = list.size();
     utf16 ulist(list[i]);
     column.pszText = ulist;
     ListView_InsertColumn(hwnd, i, &column);
   }
 
   if(text && *text) {
-    split(list, "\n", text);
-    for(unsigned i = 0; i < count(list); i++) add_item(list[i]);
+    list.split("\n", text);
+    for(unsigned i = 0; i < list.size(); i++) add_item(list[i]);
   }
   autosize_columns();
 }
@@ -47,7 +47,7 @@ void pListbox::set_column_width(unsigned column, unsigned width) {
 
 void pListbox::add_item(const char *text) {
   lstring list;
-  split(list, "\t", text ? text : "");
+  list.split("\t", text ? text : "");
   LVITEM item;
   unsigned pos = ListView_GetItemCount(hwnd);
   item.mask = LVIF_TEXT;
@@ -57,7 +57,7 @@ void pListbox::add_item(const char *text) {
   item.pszText = wtext;
   ListView_InsertItem(hwnd, &item);
 
-  for(unsigned i = 1; i < count(list); i++) {
+  for(unsigned i = 1; i < list.size(); i++) {
     utf16 wtext(list[i]);
     ListView_SetItemText(hwnd, pos, i, wtext);
   }
@@ -65,8 +65,8 @@ void pListbox::add_item(const char *text) {
 
 void pListbox::set_item(unsigned index, const char *text) {
   lstring list;
-  split(list, "\t", text ? text : "");
-  for(unsigned i = 0; i < count(list); i++) {
+  list.split("\t", text ? text : "");
+  for(unsigned i = 0; i < list.size(); i++) {
     utf16 wtext(list[i]);
     ListView_SetItemText(hwnd, index, i, wtext);
   }

src/lib/libfilter/colortable.cpp

@@ -1,9 +1,9 @@
 Colortable colortable;
 
 void Colortable::set_format(Format format_) { format = format_; }
-void Colortable::set_contrast(int32_t contrast_) { contrast = contrast_; }
-void Colortable::set_brightness(int32_t brightness_) { brightness = brightness_; }
-void Colortable::set_gamma(int32_t gamma_) { gamma = gamma_; }
+void Colortable::set_contrast(signed contrast_) { contrast = contrast_; }
+void Colortable::set_brightness(signed brightness_) { brightness = brightness_; }
+void Colortable::set_gamma(signed gamma_) { gamma = gamma_; }
 
 void Colortable::enable_gamma_ramp(bool value) { gamma_ramp = value; }
 void Colortable::enable_sepia(bool value) { sepia = value; }
@@ -11,18 +11,18 @@ void Colortable::enable_grayscale(bool value) { grayscale = value; }
 void Colortable::enable_invert(bool value) { invert = value; }
 
 void Colortable::update() {
-  int32_t l, r, g, b;
-  double kr = 0.2126, kb = 0.0722, kg = (1.0 - kr - kb); //luminance
-  uint32_t col;
-  for(unsigned i = 0; i < 32768; i++) {
-    //bgr555->rgb888
-    col = ((i & 0x001f) << 19) | ((i & 0x001c) << 14)
-        | ((i & 0x03e0) <<  6) | ((i & 0x0380) <<  1)
-        | ((i & 0x7c00) >>  7) | ((i & 0x7000) >> 12);
+  double kr = 0.2126, kb = 0.0722, kg = (1.0 - kr - kb);  //luminance weights
 
-    r = (col >> 16) & 0xff;
-    g = (col >>  8) & 0xff;
-    b = (col      ) & 0xff;
+  for(unsigned i = 0; i < 32768; i++) {
+    unsigned color  //bgr555->rgb888 conversion
+    = ((i & 0x001f) << 19) | ((i & 0x001c) << 14)
+    | ((i & 0x03e0) <<  6) | ((i & 0x0380) <<  1)
+    | ((i & 0x7c00) >>  7) | ((i & 0x7000) >> 12);
+
+    signed l;
+    signed r = (color >> 16) & 0xff;
+    signed g = (color >>  8) & 0xff;
+    signed b = (color      ) & 0xff;
 
     if(gamma_ramp == true) {
       r = gamma_ramp_table[r >> 3];
@@ -30,17 +30,31 @@ void Colortable::update() {
       b = gamma_ramp_table[b >> 3];
     }
 
-    contrast_adjust(r); brightness_adjust(r); gamma_adjust(r);
-    contrast_adjust(g); brightness_adjust(g); gamma_adjust(g);
-    contrast_adjust(b); brightness_adjust(b); gamma_adjust(b);
+    if(contrast != 0) {
+      r = contrast_adjust(r);
+      g = contrast_adjust(g);
+      b = contrast_adjust(b);
+    }
+
+    if(brightness != 0) {
+      r = brightness_adjust(r);
+      g = brightness_adjust(g);
+      b = brightness_adjust(b);
+    }
+
+    if(gamma != 100) {
+      r = gamma_adjust(r);
+      g = gamma_adjust(g);
+      b = gamma_adjust(b);
+    }
 
     if(sepia == true) {
-      l = (int32_t)((double)r * kr + (double)g * kg + (double)b * kb);
+      l = (signed)((double)r * kr + (double)g * kg + (double)b * kb);
       l = max(0, min(255, l));
 
-      r = (int32_t)((double)l * (1.0 + 0.300));
-      g = (int32_t)((double)l * (1.0 - 0.055));
-      b = (int32_t)((double)l * (1.0 - 0.225));
+      r = (signed)((double)l * (1.0 + 0.300));
+      g = (signed)((double)l * (1.0 - 0.055));
+      b = (signed)((double)l * (1.0 - 0.225));
 
       r = max(0, min(255, r));
       g = max(0, min(255, g));
@@ -48,7 +62,7 @@ void Colortable::update() {
     }
 
     if(grayscale == true) {
-      l = (int32_t)((double)r * kr + (double)g * kg + (double)b * kb);
+      l = (signed)((double)r * kr + (double)g * kg + (double)b * kb);
       l = max(0, min(255, l));
       r = g = b = l;
     }
@@ -79,7 +93,7 @@ void Colortable::update() {
       } break;
 
       default: {
-        table[i] = -1U;
+        table[i] = ~0;
       } break;
     }
   }
@@ -90,14 +104,17 @@ Colortable::Colortable() {
   contrast = 0;
   brightness = 0;
   gamma = 100;
+
+  gamma_ramp = false;
+  sepia = false;
+  grayscale = false;
+  invert = false;
 }
 
 Colortable::~Colortable() {
   delete[] table;
 }
 
-/* internal */
-
 const uint8_t Colortable::gamma_ramp_table[32] = {
   0x00, 0x01, 0x03, 0x06, 0x0a, 0x0f, 0x15, 0x1c,
   0x24, 0x2d, 0x37, 0x42, 0x4e, 0x5b, 0x69, 0x78,
@@ -105,19 +122,17 @@ const uint8_t Colortable::gamma_ramp_table[32] = {
   0xc8, 0xd0, 0xd8, 0xe0, 0xe8, 0xf0, 0xf8, 0xff,
 };
 
-void Colortable::contrast_adjust(int32_t &input) {
-  double lmin =   0.0 - (double)contrast;
-  double lmax = 255.0 + (double)contrast;
-  int32_t result = (int32_t)(lmin + (double)input * ((lmax - lmin) / 256.0));
-  input = max(0, min(255, result));
+uint8_t Colortable::contrast_adjust(uint8_t input) {
+  signed result = input - contrast + (2 * contrast * input + 127) / 255;
+  return max(0, min(255, result));
 }
 
-void Colortable::brightness_adjust(int32_t &input) {
-  int32_t result = input + brightness;
-  input = max(0, min(255, result));
+uint8_t Colortable::brightness_adjust(uint8_t input) {
+  signed result = input + brightness;
+  return max(0, min(255, result));
 }
 
-void Colortable::gamma_adjust(int32_t &input) {
-  int32_t result = (int32_t)(pow(((double)(input + 1) / 256.0), (double)gamma / 100.0) * 256.0);
-  input = max(0, min(255, result));
+uint8_t Colortable::gamma_adjust(uint8_t input) {
+  signed result = (signed)(pow(((double)input / 255.0), (double)gamma / 100.0) * 255.0 + 0.5);
+  return max(0, min(255, result));
 }

src/lib/libfilter/colortable.hpp

@@ -9,9 +9,9 @@ public:
   const inline uint32_t operator[](uint16_t index) const { return table[index]; }
 
   void set_format(Format);
-  void set_contrast(int32_t);
-  void set_brightness(int32_t);
-  void set_gamma(int32_t);
+  void set_contrast(signed);
+  void set_brightness(signed);
+  void set_gamma(signed);
   void enable_gamma_ramp(bool);
   void enable_sepia(bool);
   void enable_grayscale(bool);
@@ -26,9 +26,9 @@ private:
   uint32_t *table;
   Format format;
 
-  int32_t contrast;
-  int32_t brightness;
-  int32_t gamma;
+  signed contrast;
+  signed brightness;
+  signed gamma;
 
   bool gamma_ramp;
   bool sepia;
@@ -36,9 +36,9 @@ private:
   bool invert;
 
   static const uint8_t gamma_ramp_table[32];
-  void contrast_adjust(int32_t &input);
-  void brightness_adjust(int32_t &input);
-  void gamma_adjust(int32_t &input);
+  uint8_t contrast_adjust(uint8_t input);
+  uint8_t brightness_adjust(uint8_t input);
+  uint8_t gamma_adjust(uint8_t input);
 };
 
 extern Colortable colortable;

src/lib/libfilter/ntsc.hpp

@@ -3,6 +3,7 @@
 class NTSCFilter : public Filter {
 public:
   void render(uint32_t*, unsigned, unsigned&, unsigned&, uint16_t*, unsigned, unsigned*, unsigned, unsigned);
+  void adjust(float hue, float saturation, float contrast, float brightness, float sharpness, bool merge_fields);
 
   NTSCFilter();
   ~NTSCFilter();
@@ -10,8 +11,6 @@ public:
 private:
   struct snes_ntsc_t *ntsc;
   int burst, burst_toggle;
-
-  void adjust(float hue, float saturation, float contrast, float brightness, float sharpness, bool merge_fields);
 };
 
 extern NTSCFilter filter_ntsc;

src/lib/nall/algorithm.hpp

@@ -1,27 +1,23 @@
 #ifndef NALL_ALGORITHM_HPP
 #define NALL_ALGORITHM_HPP
 
-namespace nall {
-
 #undef min
 #undef max
 
-template<typename T, typename U>
-T min(const T& t, const U& u) {
-  return t < u ? t : u;
+namespace nall {
+  template<typename T, typename U> T min(const T& t, const U& u) {
+    return t < u ? t : u;
+  }
+
+  template<typename T, typename U> T max(const T& t, const U& u) {
+    return t > u ? t : u;
+  }
+
+  //pseudo-random number generator
+  inline unsigned prng() {
+    static unsigned n = 0;
+    return n = (n >> 1) ^ (((n & 1) - 1) & 0xedb88320);
+  }
 }
 
-template<typename T, typename U>
-T max(const T& t, const U& u) {
-  return t > u ? t : u;
-}
-
-//pseudo-random number generator
-inline unsigned prng() {
-  static unsigned n = 0;
-  return n = (n >> 1) ^ (((n & 1) - 1) & 0xedb88320);
-}
-
-} //namespace nall
-
-#endif //ifndef NALL_ALGORITHM_HPP
+#endif

src/lib/nall/any.hpp

@@ -6,71 +6,69 @@
 #include <nall/traits.hpp>
 
 namespace nall {
+  class any {
+  public:
+    bool empty() const { return container; }
+    const std::type_info& type() const { return container ? container->type() : typeid(void); }
 
-class any {
-public:
-  bool empty() const { return container; }
-  const std::type_info& type() const { return container ? container->type() : typeid(void); }
+    template<typename T> any& operator=(const T& value_) {
+      typedef typename static_if<
+        is_array<T>::value,
+        typename remove_extent<typename add_const<T>::type>::type*,
+        T
+      >::type auto_t;
 
-  template<typename T> any& operator=(const T& value_) {
-    typedef typename static_if<
-      is_array<T>::value,
-      typename remove_extent<typename add_const<T>::type>::type*,
-      T
-    >::type auto_t;
+      if(type() == typeid(auto_t)) {
+        static_cast<holder<auto_t>*>(container)->value = (auto_t)value_;
+      } else {
+        if(container) delete container;
+        container = new holder<auto_t>((auto_t)value_);
+      }
 
-    if(type() == typeid(auto_t)) {
-      static_cast<holder<auto_t>*>(container)->value = (auto_t)value_;
-    } else {
-      if(container) delete container;
-      container = new holder<auto_t>((auto_t)value_);
+      return *this;
     }
 
-    return *this;
-  }
+    any() : container(0) {}
+    template<typename T> any(const T& value_) : container(0) { operator=(value_); }
 
-  any() : container(0) {}
-  template<typename T> any(const T& value_) : container(0) { operator=(value_); }
+  private:
+    struct placeholder {
+      virtual const std::type_info& type() const = 0;
+    } *container;
 
-private:
-  struct placeholder {
-    virtual const std::type_info& type() const = 0;
-  } *container;
+    template<typename T> struct holder : placeholder {
+      T value;
+      const std::type_info& type() const { return typeid(T); }
+      holder(const T& value_) : value(value_) {}
+    };
 
-  template<typename T> struct holder : placeholder {
-    T value;
-    const std::type_info& type() const { return typeid(T); }
-    holder(const T& value_) : value(value_) {}
+    template<typename T> friend T any_cast(any&);
+    template<typename T> friend T any_cast(const any&);
+    template<typename T> friend T* any_cast(any*);
+    template<typename T> friend const T* any_cast(const any*);
   };
 
-  template<typename T> friend T any_cast(any&);
-  template<typename T> friend T any_cast(const any&);
-  template<typename T> friend T* any_cast(any*);
-  template<typename T> friend const T* any_cast(const any*);
-};
+  template<typename T> T any_cast(any &value) {
+    typedef typename remove_reference<T>::type nonref;
+    if(value.type() != typeid(nonref)) throw;
+    return static_cast<any::holder<nonref>*>(value.container)->value;
+  }
 
-template<typename T> T any_cast(any &value) {
-  typedef typename remove_reference<T>::type nonref;
-  if(value.type() != typeid(nonref)) throw;
-  return static_cast<any::holder<nonref>*>(value.container)->value;
+  template<typename T> T any_cast(const any &value) {
+    typedef const typename remove_reference<T>::type nonref;
+    if(value.type() != typeid(nonref)) throw;
+    return static_cast<any::holder<nonref>*>(value.container)->value;
+  }
+
+  template<typename T> T* any_cast(any *value) {
+    if(!value || value->type() != typeid(T)) return 0;
+    return &static_cast<any::holder<T>*>(value->container)->value;
+  }
+
+  template<typename T> const T* any_cast(const any *value) {
+    if(!value || value->type() != typeid(T)) return 0;
+    return &static_cast<any::holder<T>*>(value->container)->value;
+  }
 }
 
-template<typename T> T any_cast(const any &value) {
-  typedef const typename remove_reference<T>::type nonref;
-  if(value.type() != typeid(nonref)) throw;
-  return static_cast<any::holder<nonref>*>(value.container)->value;
-}
-
-template<typename T> T* any_cast(any *value) {
-  if(!value || value->type() != typeid(T)) return 0;
-  return &static_cast<any::holder<T>*>(value->container)->value;
-}
-
-template<typename T> const T* any_cast(const any *value) {
-  if(!value || value->type() != typeid(T)) return 0;
-  return &static_cast<any::holder<T>*>(value->container)->value;
-}
-
-} //namespace nall
-
-#endif //ifndef NALL_ANY_HPP
+#endif

src/lib/nall/array.hpp

@@ -3,92 +3,92 @@
 
 #include <stdlib.h>
 #include <nall/algorithm.hpp>
+#include <nall/bit.hpp>
 
 namespace nall {
+  //dynamic vector array
+  //neither constructor nor destructor is ever invoked;
+  //thus, this should only be used for POD objects.
+  template<typename T> class array {
+  protected:
+    T *pool;
+    unsigned poolsize, buffersize;
 
-//dynamic vector array
-//neither constructor nor destructor is ever invoked;
-//this this should only be used for POD objects.
+  public:
+    unsigned size() const { return buffersize; }
+    unsigned capacity() const { return poolsize; }
 
-template<typename T> class array {
-protected:
-  T *pool;
-  unsigned poolsize, buffersize;
+    void reset() {
+      if(pool) free(pool);
+      pool = 0;
+      poolsize = 0;
+      buffersize = 0;
+    }
 
-  unsigned findsize(unsigned size) const {
-    if(size <=    0x100) return    0x100;
-    if(size <=    0x400) return    0x400;
-    if(size <=   0x1000) return   0x1000;
-    if(size <=   0x4000) return   0x4000;
-    if(size <=  0x10000) return  0x10000;
-    if(size <=  0x40000) return  0x40000;
-    if(size <= 0x100000) return 0x100000;
+    void reserve(unsigned newsize) {
+      if(newsize == poolsize) return;
 
-    return (size + 0x100000) & ~0xfffff;
-  }
+      pool = (T*)realloc(pool, newsize * sizeof(T));
+      poolsize = newsize;
+      buffersize = min(buffersize, newsize);
+    }
 
-public:
-  unsigned size() const { return buffersize; }
-  unsigned capacity() const { return poolsize; }
+    void resize(unsigned newsize) {
+      if(newsize > poolsize) reserve(bit::round(newsize));  //round reserve size up to power of 2
+      buffersize = newsize;
+    }
 
-  void reset() {
-    if(pool) free(pool);
-    pool = 0;
-    poolsize = 0;
-    buffersize = 0;
-  }
+    T* get(unsigned minsize = 0) {
+      if(minsize > buffersize) resize(minsize);
+      if(minsize > buffersize) throw "array[] out of bounds";
+      return pool;
+    }
 
-  void reserve(unsigned newsize) {
-    if(newsize == poolsize) return;
+    void add(const T data) {
+      operator[](buffersize) = data;
+    }
 
-    pool = (T*)realloc(pool, newsize * sizeof(T));
-    poolsize = newsize;
-    buffersize = min(buffersize, newsize);
-  }
+    signed find(const T data) {
+      for(unsigned i = 0; i < size(); i++) if(pool[i] == data) return i;
+      return -1;  //not found
+    }
 
-  void resize(unsigned newsize) {
-    if(newsize > poolsize) reserve(findsize(newsize));
-    buffersize = newsize;
-  }
+    void clear() {
+      memset(pool, 0, buffersize * sizeof(T));
+    }
 
-  T* get(unsigned minsize = 0) {
-    if(minsize > buffersize) resize(minsize);
-    if(minsize > buffersize) throw "array[] out of bounds";
-    return pool;
-  }
+    array() {
+      pool = 0;
+      poolsize = 0;
+      buffersize = 0;
+    }
 
-  void add(const T data) { operator[](buffersize) = data; }
-  void clear() { memset(pool, 0, buffersize * sizeof(T)); }
+    ~array() { reset(); }
 
-  array() {
-    pool = 0;
-    poolsize = 0;
-    buffersize = 0;
-  }
+    array(const array &source) : pool(0) {
+      operator=(source);
+    }
 
-  ~array() { reset(); }
+    array& operator=(const array &source) {
+      if(pool) free(pool);
+      buffersize = source.buffersize;
+      poolsize = source.poolsize;
+      pool = (T*)malloc(sizeof(T) * poolsize);            //allocate entire pool size,
+      memcpy(pool, source.pool, sizeof(T) * buffersize);  //... but only copy used pool objects
+      return *this;
+    }
 
-  array& operator=(const array &source) {
-    if(pool) free(pool);
-    buffersize = source.buffersize;
-    poolsize = source.poolsize;
-    pool = (T*)realloc(pool, sizeof(T) * poolsize);     //allocate entire pool size,
-    memcpy(pool, source.pool, sizeof(T) * buffersize);  //... but only copy used pool objects
-    return *this;
-  }
+    inline T& operator[](unsigned index) {
+      if(index >= buffersize) resize(index + 1);
+      if(index >= buffersize) throw "array[] out of bounds";
+      return pool[index];
+    }
 
-  inline T& operator[](unsigned index) {
-    if(index >= buffersize) resize(index + 1);
-    if(index >= buffersize) throw "array[] out of bounds";
-    return pool[index];
-  }
+    inline const T& operator[](unsigned index) const {
+      if(index >= buffersize) throw "array[] out of bounds";
+      return pool[index];
+    }
+  };
+}
 
-  inline const T& operator[](unsigned index) const {
-    if(index >= buffersize) throw "array[] out of bounds";
-    return pool[index];
-  }
-};
-
-} //namespace nall
-
-#endif //ifndef NALL_ARRAY_HPP
+#endif

src/lib/nall/base64.hpp

@@ -1,94 +1,92 @@
 #ifndef NALL_BASE64_HPP
 #define NALL_BASE64_HPP
 
+#include <string.h>
+
 #include <nall/new.hpp>
 #include <nall/stdint.hpp>
 
-#include <stdio.h>
-
 namespace nall {
+  class base64 {
+  public:
+    static bool encode(char *&output, const uint8_t* input, unsigned inlength) {
+      output = new(zeromemory) char[inlength * 8 / 6 + 6];
 
-class base64 {
-public:
-  static bool encode(char *&output, const uint8_t* input, unsigned inlength) {
-    output = new(zeromemory) char[inlength * 8 / 6 + 6];
+      unsigned i = 0, o = 0;
+      while(i < inlength) {
+        switch(i % 3) {
+          case 0: {
+            output[o++] = enc(input[i] >> 2);
+            output[o] = enc((input[i] & 3) << 4);
+          } break;
 
-    unsigned i = 0, o = 0;
-    while(i < inlength) {
-      switch(i % 3) {
-        case 0: {
-          output[o++] = enc(input[i] >> 2);
-          output[o] = enc((input[i] & 3) << 4);
-        } break;
+          case 1: {
+            uint8_t prev = dec(output[o]);
+            output[o++] = enc(prev + (input[i] >> 4));
+            output[o] = enc((input[i] & 15) << 2);
+          } break;
 
-        case 1: {
-          uint8_t prev = dec(output[o]);
-          output[o++] = enc(prev + (input[i] >> 4));
-          output[o] = enc((input[i] & 15) << 2);
-        } break;
+          case 2: {
+            uint8_t prev = dec(output[o]);
+            output[o++] = enc(prev + (input[i] >> 6));
+            output[o++] = enc(input[i] & 63);
+          } break;
+        }
 
-        case 2: {
-          uint8_t prev = dec(output[o]);
-          output[o++] = enc(prev + (input[i] >> 6));
-          output[o++] = enc(input[i] & 63);
-        } break;
+        i++;
       }
 
-      i++;
+      return true;
     }
 
-    return true;
-  }
+    static bool decode(uint8_t *&output, unsigned &outlength, const char *input) {
+      unsigned inlength = strlen(input), infix = 0;
+      output = new(zeromemory) uint8_t[inlength];
 
-  static bool decode(uint8_t *&output, unsigned &outlength, const char *input) {
-    unsigned inlength = strlen(input), infix = 0;
-    output = new(zeromemory) uint8_t[inlength];
+      unsigned i = 0, o = 0;
+      while(i < inlength) {
+        uint8_t x = dec(input[i]);
 
-    unsigned i = 0, o = 0;
-    while(i < inlength) {
-      uint8_t x = dec(input[i]);
+        switch(i++ & 3) {
+          case 0: {
+            output[o] = x << 2;
+          } break;
 
-      switch(i++ & 3) {
-        case 0: {
-          output[o] = x << 2;
-        } break;
+          case 1: {
+            output[o++] |= x >> 4;
+            output[o] = (x & 15) << 4;
+          } break;
 
-        case 1: {
-          output[o++] |= x >> 4;
-          output[o] = (x & 15) << 4;
-        } break;
+          case 2: {
+            output[o++] |= x >> 2;
+            output[o] = (x & 3) << 6;
+          } break;
 
-        case 2: {
-          output[o++] |= x >> 2;
-          output[o] = (x & 3) << 6;
-        } break;
-
-        case 3: {
-          output[o++] |= x;
-        } break;
+          case 3: {
+            output[o++] |= x;
+          } break;
+        }
       }
+
+      outlength = o;
+      return true;
     }
 
-    outlength = o;
-    return true;
-  }
+  private:
+    static char enc(uint8_t n) {
+      static char lookup_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+      return lookup_table[n & 63];
+    }
 
-private:
-  static char enc(uint8_t n) {
-    static char lookup_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-    return lookup_table[n & 63];
-  }
+    static uint8_t dec(char n) {
+      if(n >= 'A' && n <= 'Z') return n - 'A';
+      if(n >= 'a' && n <= 'z') return n - 'a' + 26;
+      if(n >= '0' && n <= '9') return n - '0' + 52;
+      if(n == '-') return 62;
+      if(n == '_') return 63;
+      return 0;
+    }
+  };
+}
 
-  static uint8_t dec(char n) {
-    if(n >= 'A' && n <= 'Z') return n - 'A';
-    if(n >= 'a' && n <= 'z') return n - 'a' + 26;
-    if(n >= '0' && n <= '9') return n - '0' + 52;
-    if(n == '-') return 62;
-    if(n == '_') return 63;
-    return 0;
-  }
-};
-
-} //namespace nall
-
-#endif //ifndef NALL_BASE64_HPP
+#endif

src/lib/nall/bit.hpp

@@ -2,27 +2,50 @@
 #define NALL_BIT_HPP
 
 namespace nall {
+  template<int bits> inline unsigned uclamp(const unsigned x) {
+    enum { y = (1U << bits) - 1 };
+    return y + ((x - y) & -(x < y));  //min(x, y);
+  }
 
-template<int bits> inline unsigned uclamp(const unsigned x) {
-  enum { y = (1U << bits) - 1 };
-  return y + ((x - y) & -(x < y)); //min(x, y);
+  template<int bits> inline unsigned uclip(const unsigned x) {
+    enum { m = (1U << bits) - 1 };
+    return (x & m);
+  }
+
+  template<int bits> inline signed sclamp(const signed x) {
+    enum { b = 1U << (bits - 1), m = (1U << (bits - 1)) - 1 };
+    return (x > m) ? m : (x < -b) ? -b : x;
+  }
+
+  template<int bits> inline signed sclip(const signed x) {
+    enum { b = 1U << (bits - 1), m = (1U << bits) - 1 };
+    return ((x & m) ^ b) - b;
+  }
+
+  namespace bit {
+    //lowest(0b1110) == 0b0010
+    template<typename T> inline T lowest(const T x) {
+      return x & -x;
+    }
+
+    //clear_lowest(0b1110) == 0b1100
+    template<typename T> inline T clear_lowest(const T x) {
+      return x & (x - 1);
+    }
+
+    //set_lowest(0b0101) == 0b0111
+    template<typename T> inline T set_lowest(const T x) {
+      return x | (x + 1);
+    }
+
+    //round up to next highest single bit:
+    //round(15) == 16, round(16) == 16, round(17) == 32
+    inline unsigned round(unsigned x) {
+      if((x & (x - 1)) == 0) return x;
+      while(x & (x - 1)) x &= x - 1;
+      return x << 1;
+    }
+  }
 }
 
-template<int bits> inline unsigned uclip(const unsigned x) {
-  enum { m = (1U << bits) - 1 };
-  return (x & m);
-}
-
-template<int bits> inline signed sclamp(const signed x) {
-  enum { b = 1U << (bits - 1), m = (1U << (bits - 1)) - 1 };
-  return (x > m) ? m : (x < -b) ? -b : x;
-}
-
-template<int bits> inline signed sclip(const signed x) {
-  enum { b = 1U << (bits - 1), m = (1U << bits) - 1 };
-  return ((x & m) ^ b) - b;
-}
-
-} //namespace nall
-
-#endif //ifndef NALL_BIT_HPP
+#endif

src/lib/nall/config.hpp

@@ -1,178 +1,124 @@
-#ifndef NALL_CONFIG_HPP
-#define NALL_CONFIG_HPP
-
-#include <nall/array.hpp>
-#include <nall/file.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-
-namespace nall {
-
-class setting;
-
-class configuration {
-public:
-  array<setting*> list;
-
-  bool load(const char *fn);
-  bool save(const char *fn) const;
-  void add(setting *setting_) { list.add(setting_); }
-};
-
-class setting {
-public:
-  enum setting_type {
-    integral_type,
-    string_type,
-  } type;
-
-  const char *name;
-  const char *description;
-
-  virtual void set(const char *input) = 0;
-  virtual void get(string &output) const = 0;
-  virtual void get_default(string &output) const = 0;
-};
-
-class integral_setting : public setting {
-public:
-  enum integral_type {
-    boolean,
-    decimal,
-    hex,
-  } type;
-
-  intmax_t value;
-  intmax_t default_value;
-
-  void set(const char *input) {
-    if(type == boolean) { value = !strcmp(input, "true"); }
-    if(type == decimal) { value = strdec(input); }
-    if(type == hex) { value = strhex(input); }
-  }
-
-  void get(string &output) const {
-    if(type == boolean) { output = value ? "true" : "false"; }
-    if(type == decimal) { output = strdec(value); }
-    if(type == hex) { output = string() << "0x" << strhex(value); }
-  }
-
-  void get_default(string &output) const {
-    if(type == boolean) { output = default_value ? "true" : "false"; }
-    if(type == decimal) { output = strdec(default_value); }
-    if(type == hex) { output = string() << "0x" << strhex(default_value); }
-  }
-
-  operator intmax_t() const { return value; }
-  integral_setting& operator=(intmax_t value_) { value = value_; return *this; }
-
-  integral_setting(const char *name_, const char *description_, integral_type type_, intmax_t value_) {
-    initialize(name_, description_, type_, value_);
-  }
-
-  integral_setting(configuration &parent, const char *name_, const char *description_, integral_type type_, intmax_t value_) {
-    initialize(name_, description_, type_, value_);
-    parent.add(this);
-  }
-
-private:
-  void initialize(const char *name_, const char *description_, integral_type type_, intmax_t value_) {
-    setting::type = setting::integral_type;
-    name = name_;
-    description = description_;
-    type = type_;
-    value = default_value = value_;
-  }
-};
-
-class string_setting : public setting {
-public:
-  string value;
-  string default_value;
-
-  void set(const char *input) { value = input; trim(value(), "\""); }
-  void get(string &output) const { output = string() << "\"" << value << "\""; }
-  void get_default(string &output) const { output = string() << "\"" << default_value << "\""; }
-
-  operator const char*() const { return value; }
-  string_setting& operator=(const char *value_) { value = value_; return *this; }
-  bool operator==(const char *value_) const { return value == value_; }
-  bool operator!=(const char *value_) const { return value != value_; }
-
-  string_setting(const char *name_, const char *description_, const char *value_) {
-    initialize(name_, description_, value_);
-  }
-
-  string_setting(configuration &parent, const char *name_, const char *description_, const char *value_) {
-    initialize(name_, description_, value_);
-    parent.add(this);
-  }
-
-private:
-  void initialize(const char *name_, const char *description_, const char *value_) {
-    setting::type = setting::string_type;
-    name = name_;
-    description = description_;
-    value = default_value = value_;
-  }
-};
-
-inline bool configuration::load(const char *fn) {
-  //load the config file into memory
-  string data;
-  if(!fread(data, fn)) return false;
-
-  //split the file into lines
-  replace(data, "\r\n", "\n");
-  qreplace(data, "\t", "");
-  qreplace(data, " ", "");
-
-  lstring line, part, subpart;
-  split(line, "\n", data);
-
-  for(unsigned i = 0; i < count(line); i++) {
-    if(strlen(line[i]) == 0) continue;
-    if(strbegin(line[i], "#")) continue;
-
-    qsplit(part, "=", line[i]);
-    for(unsigned l = 0; l < list.size(); l++) {
-      if(part[0] == list[l]->name) {
-        list[l]->set(part[1]);
-        break;
-      }
-    }
-  }
-
-  return true;
-}
-
-inline bool configuration::save(const char *fn) const {
-  file fp;
-  if(!fp.open(fn, file::mode_write)) return false;
-
-  for(unsigned i = 0; i < list.size(); i++) {
-    string data;
-    lstring line, part, subpart;
-    strcpy(data, list[i]->description);
-    replace(data, "\r\n", "\n");
-    split(line, "\n", data);
-
-    string temp;
-    for(unsigned l = 0; l < count(line); l++) {
-      if(line[l] != "") fp.print(string() << "# " << line[l] << "\r\n");
-    }
-
-    string default_, value_;
-    list[i]->get_default(default_);
-    fp.print(string() << "# (default = " << default_ << ")\r\n");
-    list[i]->get(value_);
-    fp.print(string() << list[i]->name << " = " << value_ << "\r\n\r\n");
-  }
-
-  fp.close();
-  return true;
-}
-
-} //namespace nall
-
-#endif //ifndef NALL_CONFIG_HPP
+#ifndef NALL_CONFIG_HPP
+#define NALL_CONFIG_HPP
+
+#include <nall/file.hpp>
+#include <nall/string.hpp>
+#include <nall/vector.hpp>
+
+namespace nall {
+  namespace configuration_traits {
+    template<typename T> struct is_boolean { enum { value = false }; };
+    template<> struct is_boolean<bool> { enum { value = true }; };
+
+    template<typename T> struct is_signed { enum { value = false }; };
+    template<> struct is_signed<signed> { enum { value = true }; };
+
+    template<typename T> struct is_unsigned { enum { value = false }; };
+    template<> struct is_unsigned<unsigned> { enum { value = true }; };
+
+    template<typename T> struct is_double { enum { value = false }; };
+    template<> struct is_double<double> { enum { value = true }; };
+
+    template<typename T> struct is_string { enum { value = false }; };
+    template<> struct is_string<string> { enum { value = true }; };
+  }
+
+  class configuration {
+  public:
+    enum type_t { boolean_t, signed_t, unsigned_t, double_t, string_t, unknown_t };
+    struct item_t {
+      uintptr_t data;
+      string name;
+      string desc;
+      type_t type;
+
+      string get() const {
+        switch(type) {
+          case boolean_t:  return string() << *(bool*)data;
+          case signed_t:   return string() << *(signed*)data;
+          case unsigned_t: return string() << *(unsigned*)data;
+          case double_t:   return string() << *(double*)data;
+          case string_t:   return string() << "\"" << *(string*)data << "\"";
+        }
+        return "???";
+      }
+
+      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:   trim(s, "\""); *(string*)data = s; break;
+        }
+      }
+    };
+    vector<item_t> list;
+
+    template<typename T>
+    void attach(T &data, const char *name, const char *desc = "") {
+      unsigned n = list.size();
+      list[n].data = (uintptr_t)&data;
+      list[n].name = name;
+      list[n].desc = desc;
+
+      if(configuration_traits::is_boolean<T>::value) list[n].type = boolean_t;
+      else if(configuration_traits::is_signed<T>::value) list[n].type = signed_t;
+      else if(configuration_traits::is_unsigned<T>::value) list[n].type = unsigned_t;
+      else if(configuration_traits::is_double<T>::value) list[n].type = double_t;
+      else if(configuration_traits::is_string<T>::value) list[n].type = string_t;
+      else list[n].type = unknown_t;
+    }
+
+    virtual bool load(const char *filename) {
+      string data;
+      if(data.readfile(filename) == true) {
+        data.replace("\r", "");
+        lstring line;
+        line.split("\n", data);
+
+        for(unsigned i = 0; i < line.size(); i++) {
+          int position = qstrpos(line[i], "#");
+          if(position >= 0) line[i][position] = 0;
+          if(qstrpos(line[i], " = ") < 0) continue;
+
+          lstring part;
+          part.qsplit(" = ", line[i]);
+          trim(part[0]);
+          trim(part[1]);
+
+          for(unsigned n = 0; n < list.size(); n++) {
+            if(part[0] == list[n].name) {
+              list[n].set(part[1]);
+              break;
+            }
+          }
+        }
+
+        return true;
+      } else {
+        return false;
+      }
+    }
+
+    virtual bool save(const char *filename) const {
+      file fp;
+      if(fp.open(filename, file::mode_write)) {
+        for(unsigned i = 0; i < list.size(); i++) {
+          string output;
+          output << list[i].name << " = " << list[i].get();
+          if(list[i].desc != "") output << " # " << list[i].desc;
+          output << "\r\n";
+          fp.print(output);
+        }
+
+        fp.close();
+        return true;
+      } else {
+        return false;
+      }
+    }
+  };
+}
+
+#endif

src/lib/nall/crc32.hpp

@@ -4,65 +4,63 @@
 #include <nall/stdint.hpp>
 
 namespace nall {
+  const uint32_t crc32_table[256] = {
+    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+    0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+    0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+    0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+    0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+    0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+    0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+    0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+    0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+    0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+    0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+    0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+    0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+    0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+    0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+    0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+    0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+    0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+  };
 
-const uint32_t crc32_table[256] = {
-  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
-  0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
-  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
-  0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
-  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
-  0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
-  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
-  0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
-  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
-  0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
-  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
-  0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
-  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
-  0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
-  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
-  0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
-  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
-  0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
-  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
-  0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
-  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
-  0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
-  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
-  0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
-  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
-  0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
-  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
-  0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
-  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
-  0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
-  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
-  0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
-  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
-  0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
-  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
-  0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
-  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
-  0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
-  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
-  0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
-  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
-  0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
-  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
-};
-
-inline uint32_t crc32_adjust(uint32_t crc32, uint8_t input) {
-  return ((crc32 >> 8) & 0x00ffffff) ^ crc32_table[(crc32 ^ input) & 0xff];
-}
-
-inline uint32_t crc32_calculate(const uint8_t *data, unsigned length) {
-  uint32_t crc32 = ~0;
-  for(unsigned i = 0; i < length; i++) {
-    crc32 = crc32_adjust(crc32, data[i]);
+  inline uint32_t crc32_adjust(uint32_t crc32, uint8_t input) {
+    return ((crc32 >> 8) & 0x00ffffff) ^ crc32_table[(crc32 ^ input) & 0xff];
+  }
+
+  inline uint32_t crc32_calculate(const uint8_t *data, unsigned length) {
+    uint32_t crc32 = ~0;
+    for(unsigned i = 0; i < length; i++) {
+      crc32 = crc32_adjust(crc32, data[i]);
+    }
+    return ~crc32;
   }
-  return ~crc32;
 }
 
-} //namespace nall
-
-#endif //ifndef NALL_CRC32_HPP
+#endif

src/lib/nall/detect.hpp

@@ -27,4 +27,4 @@
   #define ARCH_MSB
 #endif
 
-#endif //ifndef NALL_DETECT_HPP
+#endif