Update to v093 release.

byuu says:

Changelog:
- added Cocoa target: higan can now be compiled for OS X Lion
  [Cydrak, byuu]
- SNES/accuracy profile hires color blending improvements - fixes
  Marvelous text [AWJ]
- fixed a slight bug in SNES/SA-1 VBR support caused by a typo
- added support for multi-pass shaders that can load external textures
  (requires OpenGL 3.2+)
- added game library path (used by ananke->Import Game) to
  Settings->Advanced
- system profiles, shaders and cheats database can be stored in "all
  users" shared folders now (eg /usr/share on Linux)
- all configuration files are in BML format now, instead of XML (much
  easier to read and edit this way)
- main window supports drag-and-drop of game folders (but not game files
  / ZIP archives)
- audio buffer clears when entering a modal loop on Windows (prevents
  audio repetition with DirectSound driver)
- a substantial amount of code clean-up (probably the biggest
  refactoring to date)

One highly desired target for this release was to default to the optimal
drivers instead of the safest drivers, but because AMD drivers don't
seem to like my OpenGL 3.2 driver, I've decided to postpone that. AMD
has too big a market share. Hopefully with v093 officially released, we
can get some public input on what AMD doesn't like.

.gitignore

@@ -0,0 +1 @@
+ananke/libananke.so

Makefile

@@ -0,0 +1,106 @@
+include nall/Makefile
+
+fc  := fc
+sfc := sfc
+gb  := gb
+gba := gba
+
+profile := accuracy
+target  := ethos
+
+# options += debugger
+# arch := x86
+# console := true
+
+# compiler
+flags   += -I. -O3 -fomit-frame-pointer
+link    +=
+objects := libco
+
+# profile-guided optimization mode
+# pgo := instrument
+# pgo := optimize
+
+ifeq ($(pgo),instrument)
+  flags += -fprofile-generate
+  link += -lgcov
+else ifeq ($(pgo),optimize)
+  flags += -fprofile-use
+endif
+
+# platform
+ifeq ($(platform),x)
+  flags += -march=native
+  link += -s -Wl,-export-dynamic -ldl -lX11 -lXext
+else ifeq ($(platform),osx)
+  flags += -march=native
+else ifeq ($(platform),win)
+  ifeq ($(arch),win32)
+    flags += -m32
+    link += -m32
+  endif
+  ifeq ($(console),true)
+    link += -mconsole
+  else
+    link += -mwindows
+  endif
+  link += -s -mthreads -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32 -lole32 -lws2_32
+  link += -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc
+else
+  $(error unsupported platform.)
+endif
+
+ui := target-$(target)
+
+# implicit rules
+compile = \
+  $(strip \
+    $(if $(filter %.c,$<), \
+      $(compiler) $(cflags) $(flags) $1 -c $< -o $@, \
+      $(if $(filter %.cpp,$<), \
+        $(compiler) $(cppflags) $(flags) $1 -c $< -o $@ \
+      ) \
+    ) \
+  )
+
+%.o: $<; $(call compile)
+
+all: build;
+
+obj/libco.o: libco/libco.c libco/*
+
+include $(ui)/Makefile
+flags := $(flags) $(foreach o,$(call strupper,$(options)),-D$o)
+
+# targets
+clean:
+	-@$(call delete,obj/*.o)
+	-@$(call delete,obj/*.a)
+	-@$(call delete,obj/*.so)
+	-@$(call delete,obj/*.dylib)
+	-@$(call delete,obj/*.dll)
+	-@$(call delete,*.res)
+	-@$(call delete,*.manifest)
+
+archive:
+	if [ -f higan.tar.xz ]; then rm higan.tar.xz; fi
+	tar -cJf higan.tar.xz `ls`
+
+sync:
+ifeq ($(shell id -un),byuu)
+	if [ -d ./libco ]; then rm -r ./libco; fi
+	if [ -d ./nall ]; then rm -r ./nall; fi
+	if [ -d ./ruby ]; then rm -r ./ruby; fi
+	if [ -d ./phoenix ]; then rm -r ./phoenix; fi
+	cp -r ../libco ./libco
+	cp -r ../nall ./nall
+	cp -r ../ruby ./ruby
+	cp -r ../phoenix ./phoenix
+	rm -r libco/doc
+	rm -r libco/.test
+	rm -r nall/.test
+	rm -r ruby/.test
+	rm -r phoenix/.test
+endif
+
+help:;

ananke/Makefile

@@ -0,0 +1,46 @@
+include ../nall/Makefile
+include ../phoenix/Makefile
+
+path := /usr/local/lib
+flags := $(flags) -O3 -fomit-frame-pointer -I..
+
+all:
+	$(compiler) $(cppflags) $(flags) -fPIC -o obj/ananke.o -c ananke.cpp
+ifeq ($(platform),x)
+	$(compiler) $(link) -shared -Wl,-soname,libananke.so.1 -o libananke.so obj/ananke.o
+else ifeq ($(platform),osx)
+	$(compiler) $(link) -shared -dynamiclib -undefined suppress -flat_namespace -o libananke.dylib obj/ananke.o
+else ifeq ($(platform),win)
+	$(compiler) $(phoenixflags) -fPIC -o obj/phoenix.o -c ../phoenix/phoenix.cpp
+	$(compiler) $(link) -shared -o phoenix.dll obj/phoenix.o $(phoenixlink)
+	$(compiler) $(link) -shared -o ananke.dll obj/ananke.o -L. -lphoenix
+endif
+
+resource: force
+	sourcery resource/resource.bml resource/resource.cpp resource/resource.hpp
+
+clean:
+	-@$(call delete,obj/*.o)
+	-@$(call delete,*.so)
+
+install: uninstall
+ifeq ($(platform),x)
+	if [ ! -d ~/.config/ananke ]; then mkdir ~/.config/ananke; fi
+	sudo cp libananke.so $(path)/libananke.so.1
+	sudo ln -s $(path)/libananke.so.1 $(path)/libananke.so
+else ifeq ($(platform),osx)
+	if [ ! -d ~/Library/Application\ Support/ananke ]; then mkdir ~/Library/Application\ Support/ananke; fi
+	sudo cp libananke.dylib $(path)/libananke.1.dylib
+	sudo ln -s $(path)/libananke.1.dylib $(path)/libananke.dylib
+endif
+
+uninstall:
+ifeq ($(platform),x)
+	if [ -f $(path)/libananke.so ]; then sudo rm $(path)/libananke.so; fi
+	if [ -f $(path)/libananke.so.1 ]; then sudo rm $(path)/libananke.so.1; fi
+else ifeq ($(platform),osx)
+	if [ -f $(path)/libananke.dylib ]; then sudo rm $(path)/libananke.dylib; fi
+	if [ -f $(path)/libananke.1.dylib ]; then sudo rm $(path)/libananke.1.dylib; fi
+endif
+
+force:

ananke/ananke.cpp

@@ -0,0 +1,179 @@
+#include <nall/nall.hpp>
+#include <nall/beat/patch.hpp>
+#include "heuristics/famicom.hpp"
+#include "heuristics/super-famicom.hpp"
+#include "heuristics/game-boy.hpp"
+#include "heuristics/game-boy-advance.hpp"
+using namespace nall;
+
+#include <phoenix/phoenix.hpp>
+using namespace phoenix;
+
+namespace Database {
+  #include "database/super-famicom.hpp"
+  #include "database/sufami-turbo.hpp"
+  #include "database/bsx-satellaview.hpp"
+};
+
+struct Ananke {
+  #include "configuration.cpp"
+  string libraryPath;
+
+  Ananke();
+
+  struct Information {
+    string path;      //path to selected file
+    string name;      //name of selected file (inside of archive if .zip)
+    string archive;   //pathname of archive
+    string manifest;  //manifest from successfully applied patch
+  } information;
+
+  //archive.cpp
+  vector<uint8_t> extractROM();
+  vector<uint8_t> extractFile(const string &filename);
+
+  //patch.cpp
+  void applyBeatPatch(vector<uint8_t> &buffer);
+
+  //famicom.cpp
+  void copyFamicomSaves(const string &pathname);
+  string createFamicomHeuristic(vector<uint8_t> &buffer);
+  string openFamicom(vector<uint8_t> &buffer);
+  string syncFamicom(const string &pathname);
+
+  //super-famicom.cpp
+  void copySuperFamicomSaves(const string &pathname);
+  string createSuperFamicomDatabase(vector<uint8_t> &buffer, Markup::Node &document, const string &manifest);
+  string createSuperFamicomHeuristic(vector<uint8_t> &buffer);
+  void createSuperFamicomHeuristicFirmware(vector<uint8_t> &buffer, const string &pathname, bool firmware_appended);
+  string openSuperFamicom(vector<uint8_t> &buffer);
+  string syncSuperFamicom(const string &pathname);
+
+  //sufami-turbo.cpp
+  void copySufamiTurboSaves(const string &pathname);
+  string createSufamiTurboDatabase(vector<uint8_t> &buffer, Markup::Node &document, const string &manifest);
+  string createSufamiTurboHeuristic(vector<uint8_t> &buffer);
+  string openSufamiTurbo(vector<uint8_t> &buffer);
+  string syncSufamiTurbo(const string &pathname);
+
+  //bsx-satellaview.cpp
+  string createBsxSatellaviewDatabase(vector<uint8_t> &buffer, Markup::Node &document, const string &manifest);
+  string createBsxSatellaviewHeuristic(vector<uint8_t> &buffer);
+  string openBsxSatellaview(vector<uint8_t> &buffer);
+  string syncBsxSatellaview(const string &pathname);
+
+  //game-boy.cpp
+  void copyGameBoySaves(const string &pathname);
+  string createGameBoyHeuristic(vector<uint8_t> &buffer);
+  string openGameBoy(vector<uint8_t> &buffer);
+  string syncGameBoy(const string &pathname);
+
+  //game-boy-advance.cpp
+  void copyGameBoyAdvanceSaves(const string &pathname);
+  string createGameBoyAdvanceHeuristic(vector<uint8_t> &buffer);
+  string openGameBoyAdvance(vector<uint8_t> &buffer);
+  string syncGameBoyAdvance(const string &pathname);
+
+  static bool supported(const string &filename);
+  string open(string filename = "");
+  string sync(string pathname);
+};
+
+#include "resource/resource.cpp"
+#include "file-dialog.cpp"
+#include "archive.cpp"
+#include "patch.cpp"
+#include "famicom.cpp"
+#include "super-famicom.cpp"
+#include "sufami-turbo.cpp"
+#include "bsx-satellaview.cpp"
+#include "game-boy.cpp"
+#include "game-boy-advance.cpp"
+
+FileDialog *fileDialog = nullptr;
+
+Ananke::Ananke() {
+  libraryPath = string::read({configpath(), "higan/library.bml"}).strip().ltrim<1>("Path: ").replace("\\", "/");
+  if(libraryPath.empty()) libraryPath = {userpath(), "Emulation/"};
+  if(libraryPath.endswith("/") == false) libraryPath.append("/");
+}
+
+bool Ananke::supported(const string &filename) {
+  string extension = nall::extension(filename);
+
+  if(extension == "fc" ) return true;
+  if(extension == "nes") return true;
+  if(extension == "sfc") return true;
+  if(extension == "smc") return true;
+  if(extension == "st" ) return true;
+  if(extension == "bs" ) return true;
+  if(extension == "gb" ) return true;
+  if(extension == "gbc") return true;
+  if(extension == "gba") return true;
+  if(extension == "zip") return true;
+
+  return false;
+}
+
+string Ananke::open(string filename) {
+  if(filename.empty()) {
+    if(!fileDialog) {
+      fileDialog = new FileDialog;
+      fileDialog->setGeometry(config.geometry);
+    }
+    fileDialog->setPath(config.path);
+    filename = fileDialog->open();
+    config.geometry = fileDialog->geometry().text();
+  }
+
+  if(filename.empty()) return "";
+
+  information.path = dir(filename);
+  information.name = notdir(filename);
+  config.path = information.path;  //remember last used directory
+
+  vector<uint8_t> buffer;
+  if(filename.endswith(".zip")) {
+    information.archive = filename;
+    buffer = extractROM();
+  } else {
+    buffer = file::read(filename);
+  }
+  if(buffer.size() == 0) return "";  //failed to read file
+
+  applyBeatPatch(buffer);
+
+  if(information.name.endswith(".fc") || information.name.endswith(".nes")) return openFamicom(buffer);
+  if(information.name.endswith(".sfc") || information.name.endswith(".smc")) return openSuperFamicom(buffer);
+  if(information.name.endswith(".st")) return openSufamiTurbo(buffer);
+  if(information.name.endswith(".bs")) return openBsxSatellaview(buffer);
+  if(information.name.endswith(".gb") || information.name.endswith(".gbc")) return openGameBoy(buffer);
+  if(information.name.endswith(".gba")) return openGameBoyAdvance(buffer);
+  return "";
+}
+
+string Ananke::sync(string pathname) {
+  if(pathname.endswith(".fc/")) return syncFamicom(pathname);
+  if(pathname.endswith(".sfc/")) return syncSuperFamicom(pathname);
+  if(pathname.endswith(".st/")) return syncSufamiTurbo(pathname);
+  if(pathname.endswith(".bs/")) return syncBsxSatellaview(pathname);
+  if(pathname.endswith(".gb/")) return syncGameBoy(pathname);
+  if(pathname.endswith(".gbc/")) return syncGameBoy(pathname);
+  if(pathname.endswith(".gba/")) return syncGameBoyAdvance(pathname);
+  return "";
+}
+
+extern "C" string ananke_browse(const string &filename) {
+  Ananke ananke;
+  return ananke.open();
+}
+
+extern "C" string ananke_open(const string &filename) {
+  Ananke ananke;
+  return ananke.open(filename);
+}
+
+extern "C" string ananke_sync(const string &pathname) {
+  Ananke ananke;
+  return ananke.sync(pathname);
+}

ananke/archive.cpp

@@ -0,0 +1,29 @@
+vector<uint8_t> Ananke::extractROM() {
+  unzip archive;
+  if(archive.open(information.archive)) {
+    for(auto &file : archive.file) {
+      if(file.name.endswith(".fc")  || file.name.endswith(".nes")
+      || file.name.endswith(".sfc") || file.name.endswith(".smc")
+      || file.name.endswith(".st")  || file.name.endswith(".bs")
+      || file.name.endswith(".gb")  || file.name.endswith(".gbc")
+      || file.name.endswith(".gba")
+      ) {
+        information.name = notdir(file.name);
+        return archive.extract(file);
+      }
+    }
+  }
+  return vector<uint8_t>();
+}
+
+vector<uint8_t> Ananke::extractFile(const string &filename) {
+  unzip archive;
+  if(archive.open(information.archive)) {
+    for(auto &file : archive.file) {
+      if(notdir(file.name) == filename) {
+        return archive.extract(file);
+      }
+    }
+  }
+  return vector<uint8_t>();
+}

ananke/bsx-satellaview.cpp

@@ -0,0 +1,72 @@
+string Ananke::createBsxSatellaviewDatabase(vector<uint8_t> &buffer, Markup::Node &document, const string &manifest) {
+  string pathname = {
+    libraryPath, "BS-X Satellaview/",
+    document["release/information/name"].text(),
+    " (", document["release/information/region"].text(), ")",
+    " (", document["release/information/revision"].text(), ")",
+    ".bs/"
+  };
+  directory::create(pathname);
+
+  //strip "release" root node from database entry (since a single game manifest isn't part of a database)
+  string markup = manifest;
+  markup.replace("\n  ", "\n");
+  markup.replace("information", "\ninformation");
+  markup.ltrim<1>("release\n");
+
+  file::write({pathname, "manifest.bml"}, markup);
+  file::write({pathname, "program.rom"}, buffer);
+
+  return pathname;
+}
+
+string Ananke::createBsxSatellaviewHeuristic(vector<uint8_t> &buffer) {
+  string pathname = {
+    libraryPath, "BS-X Satellaview/",
+    nall::basename(information.name),
+    ".bs/"
+  };
+  directory::create(pathname);
+
+  file::write({pathname, "manifest.bml"}, {
+    "unverified\n",
+    "\n",
+    "cartridge\n",
+    "  rom name=program.rom size=0x", hex(buffer.size()), " type=FlashROM\n",
+    "\n",
+    "information\n",
+    "  title: ", nall::basename(information.name), "\n"
+  });
+  file::write({pathname, "program.rom"}, buffer);
+
+  return pathname;
+}
+
+string Ananke::openBsxSatellaview(vector<uint8_t> &buffer) {
+  string sha256 = nall::sha256(buffer.data(), buffer.size());
+
+  string databaseText = string::read({configpath(), "ananke/database/BS-X Satellaview.bml"}).strip();
+  if(databaseText.empty()) databaseText = string{Database::BsxSatellaview}.strip();
+  lstring databaseItem = databaseText.split("\n\n");
+
+  for(auto &item : databaseItem) {
+    item.append("\n");
+    auto document = Markup::Document(item);
+
+    if(document["release/information/sha256"].text() == sha256) {
+      return createBsxSatellaviewDatabase(buffer, document, item);
+    }
+  }
+
+  return createBsxSatellaviewHeuristic(buffer);
+}
+
+string Ananke::syncBsxSatellaview(const string &pathname) {
+  auto buffer = file::read({pathname, "program.rom"});
+  if(buffer.size() == 0) return "";
+
+  directory::remove(pathname);
+  information.path = pathname;
+  information.name = notdir(string{pathname}.rtrim<1>("/"));
+  return openBsxSatellaview(buffer);
+}

ananke/configuration.cpp

@@ -0,0 +1,17 @@
+struct Settings : Configuration::Document {
+  string path;
+  string geometry;
+
+  Settings() {
+    Configuration::Node node;
+    node.append(path = userpath(), "Path");
+    node.append(geometry = "64,64,480,600", "Geometry");
+    append(node, "Settings");
+    directory::create({configpath(), "ananke/"});
+    load({configpath(), "ananke/settings.bml"});
+  }
+
+  ~Settings() {
+    save({configpath(), "ananke/settings.bml"});
+  }
+} config;

ananke/database/bsx-satellaview.hpp

@@ -0,0 +1,19 @@
+string BsxSatellaview = R"(
+
+database revision=2013-01-22
+
+release
+  cartridge
+    rom name=program.rom size=0x80000 type=MaskROM
+  information
+    title:    鮫亀 キャラカセット
+    name:     Same Game - Character Cassette
+    region:   JP
+    revision: 1.0
+    board:    BSMC-CR-01
+    serial:   BSMC-ZS5J-JPN
+    sha256:   80c34b50817d58820bc8c88d2d9fa462550b4a76372e19c6467cbfbc8cf5d9ef
+    configuration
+      rom name=program.rom size=0x80000 type=MaskROM
+
+)";

ananke/database/sufami-turbo.hpp

@@ -0,0 +1,162 @@
+string SufamiTurbo = R"(
+
+database revision=2013-01-22
+
+release
+  cartridge linkable
+    rom name=program.rom size=0x80000
+    ram name=save.ram size=0x800
+  information
+    title:    SDウルトラバトル ウルトラマン伝説
+    name:     SD Ultra Battle - Ultraman Densetsu
+    region:   JP
+    revision: 1.0
+    serial:   SFT-0101-JPN
+    sha256:   2bb55214fb668ca603d7b944b14f105dfb10b987a8902d420fe4ae1cb69c1d4a
+    configuration
+      rom name=program.rom size=0x80000
+      ram name=save.ram size=0x800
+      linkable
+
+release
+  cartridge linkable
+    rom name=program.rom size=0x80000
+    ram name=save.ram size=0x800
+  information
+    title:    SDウルトラバトル セブン伝説
+    name:     SD Ultra Battle - Seven Densetsu
+    region:   JP
+    revision: 1.0
+    serial:   SFT-0102-JPN
+    sha256:   2fec5f2bc7dee010af10569a3d2bc18715a79a126940800c3eade5abbd625e3f
+    configuration
+      rom name=program.rom size=0x80000
+      ram name=save.ram size=0x800
+      linkable
+
+release
+  cartridge linkable
+    rom name=program.rom size=0x80000
+    ram name=save.ram size=0x800
+  information
+    title:    ポイポイ忍者ワールド
+    name:     Poi Poi Ninja World
+    region:   JP
+    revision: 1.0
+    serial:   SFT-0103-JPN
+    sha256:   602b20b788640f5743487108a10f3f77bca5ce2d24208b25b1ca498a96eb0d69
+    configuration
+      rom name=program.rom size=0x80000
+      ram name=save.ram size=0x800
+      linkable
+
+release
+  cartridge linkable
+    rom name=program.rom size=0x80000
+    ram name=save.ram size=0x2000
+  information
+    title:    SDガンダムジェネレーション 一年戦争記
+    name:     SD Gundam Generation - Ichinen Sensouki
+    region:   JP
+    revision: 1.0
+    serial:   SFT-0104-JPN
+    sha256:   3e82215bed08274874b30d461fc4a965c6bca932229da5d46d56e36f484d65eb
+    configuration
+      rom name=program.rom size=0x80000
+      ram name=save.ram size=0x2000
+      linkable
+
+release
+  cartridge linkable
+    rom name=program.rom size=0x80000
+    ram name=save.ram size=0x2000
+  information
+    title:    SDガンダムジェネレーション グリプス戦記
+    name:     SD Gundam Generation - Grips Senki
+    region:   JP
+    revision: 1.0
+    serial:   SFT-0105-JPN
+    sha256:   8547a08ed11fe408eac282a90ac46654bd2e5f49bda3aec8e5edf166a0a4b9af
+    configuration
+      rom name=program.rom size=0x80000
+      ram name=save.ram size=0x2000
+      linkable
+
+release
+  cartridge
+    rom name=program.rom size=0x80000
+  information
+    title:    ゲゲゲの鬼太郎 妖怪ドンジャラ
+    name:     Gegege no Kitarou - Youkai Donjara
+    region:   JP
+    revision: 1.0
+    serial:   SFT-0106-JPN
+    sha256:   d93b3a570e7cf343f680ab0768a50b77e3577f9c555007e2de3decd6bc4765c8
+    configuration
+      rom name=program.rom size=0x80000
+
+release
+  cartridge linkable
+    rom name=program.rom size=0x80000
+    ram name=save.ram size=0x2000
+  information
+    title:    SDガンダムジェネレーション アクシズ戦記
+    name:     SD Gundam Generation - Axis Senki
+    region:   JP
+    revision: 1.0
+    serial:   SFT-0107-JPN
+    sha256:   2a9d7c9a61318861028a73ca03e32a48cff162d76cba36fbaab8690b212efe9b
+    configuration
+      rom name=program.rom size=0x80000
+      ram name=save.ram size=0x2000
+      linkable
+
+release
+  cartridge linkable
+    rom name=program.rom size=0x80000
+    ram name=save.ram size=0x2000
+  information
+    title:    SDガンダムジェネレーション バビロニア建国戦記
+    name:     SD Gundam Generation - Babylonia Kenkoku Senki
+    region:   JP
+    revision: 1.0
+    serial:   SFT-0108-JPN
+    sha256:   60ac017c18f534e8cf24ca7f38e22ce92db95ea6c30b2d59d76f13c4f1c8a6e4
+    configuration
+      rom name=program.rom size=0x80000
+      ram name=save.ram size=0x2000
+      linkable
+
+release
+  cartridge linkable
+    rom name=program.rom size=0x80000
+    ram name=save.ram size=0x2000
+  information
+    title:    SDガンダムジェネレーション ザンスカール戦記
+    name:     SD Gundam Generation - Zanscar Senki
+    region:   JP
+    revision: 1.0
+    serial:   SFT-0110-JPN
+    sha256:   5951a58a91d8e397d0a237ccc2b1248e17c7312cb9cc11cbc350200a97b4e021
+    configuration
+      rom name=program.rom size=0x80000
+      ram name=save.ram size=0x2000
+      linkable
+
+release
+  cartridge linkable
+    rom name=program.rom size=0x80000
+    ram name=save.ram size=0x800
+  information
+    title:    SDガンダムジェネレーション コロニー格闘記
+    name:     SD Gundam Generation - Colony Kakutouki
+    region:   JP
+    revision: 1.0
+    serial:   SFT-0111-JPN
+    sha256:   e639b5d5d722432b6809ccc6801dc584e1a3016379f34b335ed2dfa73b1ebf69
+    configuration
+      rom name=program.rom size=0x80000
+      ram name=save.ram size=0x800
+      linkable
+
+)";

ananke/famicom.cpp

@@ -0,0 +1,39 @@
+void Ananke::copyFamicomSaves(const string &pathname) {
+  if(!file::exists({pathname, "save.ram"})) {
+    if(file::exists({information.path, nall::basename(information.name), ".sav"})) {
+      file::copy({information.path, nall::basename(information.name), ".srm"}, {pathname, "save.ram"});
+    }
+  }
+}
+
+string Ananke::createFamicomHeuristic(vector<uint8_t> &buffer) {
+  string pathname = {
+    libraryPath, "Famicom/",
+    nall::basename(information.name),
+    ".fc/"
+  };
+  directory::create(pathname);
+
+  FamicomCartridge info(buffer.data(), buffer.size());
+  string markup = {"unverified\n\n", info.markup};
+  markup.append("\ninformation\n  title: ", nall::basename(information.name), "\n");
+  if(!information.manifest.empty()) markup = information.manifest;  //override with embedded beat manifest, if one exists
+
+  file::write({pathname, "manifest.bml"}, markup);
+  file::write({pathname, "program.rom"}, buffer.data() + 16, info.prgrom);
+  if(info.chrrom > 0) file::write({pathname, "character.rom"}, buffer.data() + 16 + info.prgrom, info.chrrom);
+
+  copyFamicomSaves(pathname);
+  return pathname;
+}
+
+string Ananke::openFamicom(vector<uint8_t> &buffer) {
+  return createFamicomHeuristic(buffer);
+}
+
+//this currently cannot work:
+//game folders discard iNES header required for heuristic detection
+//a games database of all commercial Famicom software will be required
+string Ananke::syncFamicom(const string &pathname) {
+  return "";
+}

ananke/file-dialog.cpp

@@ -0,0 +1,106 @@
+struct FileDialog : Window {
+  VerticalLayout layout;
+    HorizontalLayout pathLayout;
+      LineEdit pathEdit;
+      Button homeButton;
+      Button upButton;
+    ListView fileList;
+    HorizontalLayout controlLayout;
+      Label filterLabel;
+      Button openButton;
+
+  string open() {
+    setVisible();
+    fileList.setFocused();
+    filename = "";
+
+    setModal();
+    return filename;
+  }
+
+  void setPath(const string &path) {
+    pathname = string{path}.transform("\\", "/");
+    if(pathname.empty()) pathname = userpath();
+    if(pathname.endswith("/") == false) pathname.append("/");
+    pathEdit.setText(pathname);
+
+    fileList.reset();
+    filenameList.reset();
+
+    lstring folders = directory::ifolders(pathname);
+    for(auto &folder : folders) {
+      fileList.append(string{folder}.rtrim<1>("/"));
+      fileList.setImage(filenameList.size(), 0, {resource::folder, sizeof resource::folder});
+      filenameList.append({pathname, folder});
+    }
+
+    lstring files = directory::ifiles(pathname);
+    for(auto &file : files) {
+      if(Ananke::supported(file) == false) continue;  //ignore unsupported extensions
+      fileList.append(file);
+      if(extension(file) == "zip") {
+        fileList.setImage(filenameList.size(), 0, {resource::archive, sizeof resource::archive});
+      } else {
+        fileList.setImage(filenameList.size(), 0, {resource::file, sizeof resource::file});
+      }
+      filenameList.append({pathname, file});
+    }
+
+    fileList.setSelection(0);
+    fileList.setSelected();
+    fileList.setFocused();
+  }
+
+  FileDialog() {
+    setTitle("Load Image");
+
+    layout.setMargin(5);
+    homeButton.setImage({resource::home, sizeof resource::home});
+    upButton.setImage({resource::up, sizeof resource::up});
+    filterLabel.setText("Filter: *.fc, *.sfc, *.st, *.bs, *.gb, *.gbc, *.gba, *.nes, *.smc, *.zip");
+    openButton.setText("Open");
+
+    append(layout);
+    layout.append(pathLayout, {~0, 0}, 5);
+      pathLayout.append(pathEdit, {~0, 0}, 5);
+      pathLayout.append(homeButton, {28, 28}, 5);
+      pathLayout.append(upButton, {28, 28});
+    layout.append(fileList, {~0, ~0}, 5);
+    layout.append(controlLayout, {~0, 0});
+      controlLayout.append(filterLabel, {~0, 0}, 5);
+      controlLayout.append(openButton, {80, 0});
+
+    pathEdit.onActivate = [&] {
+      string path = pathEdit.text();
+      setPath(path);
+    };
+
+    homeButton.onActivate = [&] {
+      setPath(userpath());
+    };
+
+    upButton.onActivate = [&] {
+      setPath(parentdir(pathname));
+    };
+
+    fileList.onActivate = openButton.onActivate = [&] {
+      if(fileList.selected() == false) return;
+      string name = filenameList(fileList.selection());
+      if(name.empty()) return;
+
+      if(name.endswith("/")) return setPath(name);
+      filename = name;
+      onClose();
+    };
+
+    onClose = [&] {
+      setModal(false);
+      setVisible(false);
+    };
+  }
+
+private:
+  string pathname;
+  string filename;
+  lstring filenameList;
+};

ananke/game-boy-advance.cpp

@@ -0,0 +1,58 @@
+void Ananke::copyGameBoyAdvanceSaves(const string &pathname) {
+  if(!file::exists({pathname, "save.ram"})) {
+    if(file::exists({information.path, nall::basename(information.name), ".sav"})) {
+      file::copy({information.path, nall::basename(information.name), ".sav"}, {pathname, "save.ram"});
+    }
+  }
+
+  if(!file::exists({pathname, "rtc.ram"})) {
+    if(file::exists({information.path, nall::basename(information.name), ".rtc"})) {
+      file::copy({information.path, nall::basename(information.name), ".rtc"}, {pathname, "rtc.ram"});
+    }
+  }
+}
+
+string Ananke::createGameBoyAdvanceHeuristic(vector<uint8_t> &buffer) {
+  string pathname = {
+    libraryPath, "Game Boy Advance/",
+    nall::basename(information.name),
+    ".gba/"
+  };
+  directory::create(pathname);
+
+  GameBoyAdvanceCartridge info(buffer.data(), buffer.size());
+  string markup = {"unverified\n\n", info.markup};
+  markup.append("\ninformation\n  title: ", nall::basename(information.name), "\n");
+  if(!information.manifest.empty()) markup = information.manifest;  //override with embedded beat manifest, if one exists
+
+  file::write({pathname, "manifest.bml"}, markup);
+  file::write({pathname, "program.rom"}, buffer);
+
+  copyGameBoyAdvanceSaves(pathname);
+  return pathname;
+}
+
+string Ananke::openGameBoyAdvance(vector<uint8_t> &buffer) {
+  return createGameBoyAdvanceHeuristic(buffer);
+}
+
+string Ananke::syncGameBoyAdvance(const string &pathname) {
+  auto buffer = file::read({pathname, "program.rom"});
+  if(buffer.size() == 0) return "";
+
+  auto save = file::read({pathname, "save.ram"});
+  if(save.size() == 0) save = file::read({pathname, "save.rwm"});
+
+  auto rtc = file::read({pathname, "rtc.ram"});
+  if(rtc.size() == 0) rtc = file::read({pathname, "rtc.rwm"});
+
+  directory::remove(pathname);
+  information.path = pathname;
+  information.name = notdir(string{pathname}.rtrim<1>("/"));
+  string outputPath = openGameBoyAdvance(buffer);
+
+  if(save.size()) file::write({outputPath, "save.ram"}, save);
+  if(rtc.size()) file::write({outputPath, "rtc.ram"}, rtc);
+
+  return outputPath;
+}

ananke/game-boy.cpp

@@ -0,0 +1,59 @@
+void Ananke::copyGameBoySaves(const string &pathname) {
+  if(!file::exists({pathname, "save.ram"})) {
+    if(file::exists({information.path, nall::basename(information.name), ".sav"})) {
+      file::copy({information.path, nall::basename(information.name), ".sav"}, {pathname, "save.ram"});
+    }
+  }
+
+  if(!file::exists({pathname, "rtc.ram"})) {
+    if(file::exists({information.path, nall::basename(information.name), ".rtc"})) {
+      file::copy({information.path, nall::basename(information.name), ".rtc"}, {pathname, "rtc.ram"});
+    }
+  }
+}
+
+string Ananke::createGameBoyHeuristic(vector<uint8_t> &buffer) {
+  GameBoyCartridge info(buffer.data(), buffer.size());
+
+  string pathname = {
+    libraryPath, "Game Boy", (info.info.cgb ? " Color" : ""), "/",
+    nall::basename(information.name),
+    ".", (info.info.cgb ? "gbc" : "gb"), "/"
+  };
+  directory::create(pathname);
+
+  string markup = {"unverified\n\n", info.markup};
+  markup.append("\ninformation\n  title: ", nall::basename(information.name), "\n");
+  if(!information.manifest.empty()) markup = information.manifest;  //override with embedded beat manifest, if one exists
+
+  file::write({pathname, "manifest.bml"}, markup);
+  file::write({pathname, "program.rom"}, buffer);
+
+  copyGameBoySaves(pathname);
+  return pathname;
+}
+
+string Ananke::openGameBoy(vector<uint8_t> &buffer) {
+  return createGameBoyHeuristic(buffer);
+}
+
+string Ananke::syncGameBoy(const string &pathname) {
+  auto buffer = file::read({pathname, "program.rom"});
+  if(buffer.size() == 0) return "";
+
+  auto save = file::read({pathname, "save.ram"});
+  if(save.size() == 0) save = file::read({pathname, "save.rwm"});
+
+  auto rtc = file::read({pathname, "rtc.ram"});
+  if(rtc.size() == 0) rtc = file::read({pathname, "rtc.rwm"});
+
+  directory::remove(pathname);
+  information.path = pathname;
+  information.name = notdir(string{pathname}.rtrim<1>("/"));
+  string outputPath = openGameBoy(buffer);
+
+  if(save.size()) file::write({outputPath, "save.ram"}, save);
+  if(rtc.size()) file::write({outputPath, "rtc.ram"}, rtc);
+
+  return outputPath;
+}

ananke/heuristics/famicom.hpp

@@ -0,0 +1,173 @@
+#ifndef NALL_EMULATION_FAMICOM_HPP
+#define NALL_EMULATION_FAMICOM_HPP
+
+#include <nall/sha256.hpp>
+#include <nall/string.hpp>
+
+namespace nall {
+
+struct FamicomCartridge {
+  string markup;
+  inline FamicomCartridge(const uint8_t *data, unsigned size);
+
+//private:
+  unsigned mapper;
+  unsigned mirror;
+  unsigned prgrom;
+  unsigned prgram;
+  unsigned chrrom;
+  unsigned chrram;
+};
+
+FamicomCartridge::FamicomCartridge(const uint8_t *data, unsigned size) {
+  markup = "";
+  if(size < 16) return;
+  if(data[0] != 'N') return;
+  if(data[1] != 'E') return;
+  if(data[2] != 'S') return;
+  if(data[3] !=  26) return;
+
+  mapper = ((data[7] >> 4) << 4) | (data[6] >> 4);
+  mirror = ((data[6] & 0x08) >> 2) | (data[6] & 0x01);
+  prgrom = data[4] * 0x4000;
+  chrrom = data[5] * 0x2000;
+  prgram = 0u;
+  chrram = chrrom == 0u ? 8192u : 0u;
+
+  markup.append("cartridge\n");
+
+  switch(mapper) {
+  default:
+    markup.append("  board type=NES-NROM-256\n");
+    markup.append("  mirror mode=", mirror == 0 ? "horizontal" : "vertical", "\n");
+    break;
+
+  case   1:
+    markup.append("  board type=NES-SXROM\n");
+    markup.append("  chip type=MMC1B2\n");
+    prgram = 8192;
+    break;
+
+  case   2:
+    markup.append("  board type=NES-UOROM\n");
+    markup.append("  mirror mode=", mirror == 0 ? "horizontal" : "vertical", "\n");
+    break;
+
+  case   3:
+    markup.append("  board type=NES-CNROM\n");
+    markup.append("  mirror mode=", mirror == 0 ? "horizontal" : "vertical", "\n");
+    break;
+
+  case   4:
+    //MMC3
+    markup.append("  board type=NES-TLROM\n");
+    markup.append("  chip type=MMC3B\n");
+    prgram = 8192;
+    //MMC6
+  //markup.append("  board type=NES-HKROM\n");
+  //markup.append("  chip type=MMC6n");
+  //prgram = 1024;
+    break;
+
+  case   5:
+    markup.append("  board type=NES-ELROM\n");
+    markup.append("  chip type=MMC5\n");
+    prgram = 65536;
+    break;
+
+  case   7:
+    markup.append("  board type=NES-AOROM\n");
+    break;
+
+  case   9:
+    markup.append("  board type=NES-PNROM\n");
+    markup.append("  chip type=MMC2\n");
+    prgram = 8192;
+    break;
+
+  case  10:
+    markup.append("  board type=NES-FKROM\n");
+    markup.append("  chip type=MMC4\n");
+    prgram = 8192;
+    break;
+
+  case  16:
+    markup.append("  board type=BANDAI-FCG\n");
+    markup.append("  chip type=LZ93D50\n");
+    break;
+
+  case  21:
+  case  23:
+  case  25:
+    //VRC4
+    markup.append("  board type=KONAMI-VRC-4\n");
+    markup.append("  chip type=VRC4\n");
+    markup.append("    pinout a0=1 a1=0\n");
+    prgram = 8192;
+    break;
+
+  case  22:
+    //VRC2
+    markup.append("  board type=KONAMI-VRC-2\n");
+    markup.append("  chip type=VRC2\n");
+    markup.append("    pinout a0=0 a1=1\n");
+    break;
+
+  case  24:
+    markup.append("  board type=KONAMI-VRC-6\n");
+    markup.append("  chip type=VRC6\n");
+    break;
+
+  case  26:
+    markup.append("  board type=KONAMI-VRC-6\n");
+    markup.append("  chip type=VRC6\n");
+    prgram = 8192;
+    break;
+
+  case  34:
+    markup.append("  board type=NES-BNROM\n");
+    markup.append("  mirror mode=", mirror == 0 ? "horizontal" : "vertical", "\n");
+    break;
+
+  case  66:
+    markup.append("  board type=NES-GNROM\n");
+    markup.append("  mirror mode=", mirror == 0 ? "horizontal" : "vertical", "\n");
+    break;
+
+  case  69:
+    markup.append("  board type=SUNSOFT-5B\n");
+    markup.append("  chip type=5B\n");
+    prgram = 8192;
+    break;
+
+  case  73:
+    markup.append("  board type=KONAMI-VRC-3\n");
+    markup.append("  chip type=VRC3\n");
+    markup.append("  mirror mode=", mirror == 0 ? "horizontal" : "vertical", "\n");
+    prgram = 8192;
+    break;
+
+  case  75:
+    markup.append("  board type=KONAMI-VRC-1\n");
+    markup.append("  chip type=VRC1\n");
+    break;
+
+  case  85:
+    markup.append("  board type=KONAMI-VRC-7\n");
+    markup.append("  chip type=VRC7\n");
+    prgram = 8192;
+    break;
+  }
+
+  markup.append("  prg\n");
+  if(prgrom) markup.append("    rom name=program.rom size=0x", hex(prgrom), "\n");
+  if(prgram) markup.append("    ram name=save.ram size=0x", hex(prgram), "\n");
+
+  markup.append("  chr\n");
+  if(chrrom) markup.append("    rom name=character.rom size=0x", hex(chrrom), "\n");
+  if(chrram) markup.append("    ram size=0x", hex(chrram), "\n");
+}
+
+}
+
+#endif

ananke/heuristics/game-boy-advance.hpp

@@ -0,0 +1,63 @@
+#ifndef NALL_EMULATION_GAME_BOY_ADVANCE_HPP
+#define NALL_EMULATION_GAME_BOY_ADVANCE_HPP
+
+#include <nall/sha256.hpp>
+#include <nall/string.hpp>
+#include <nall/vector.hpp>
+
+namespace nall {
+
+struct GameBoyAdvanceCartridge {
+  string markup;
+  string identifiers;
+  inline GameBoyAdvanceCartridge(const uint8_t *data, unsigned size);
+};
+
+GameBoyAdvanceCartridge::GameBoyAdvanceCartridge(const uint8_t *data, unsigned size) {
+  struct Identifier {
+    string name;
+    unsigned size;
+  };
+  vector<Identifier> idlist;
+  idlist.append({"SRAM_V",      6});
+  idlist.append({"SRAM_F_V",    8});
+  idlist.append({"EEPROM_V",    8});
+  idlist.append({"FLASH_V",     7});
+  idlist.append({"FLASH512_V", 10});
+  idlist.append({"FLASH1M_V",   9});
+
+  lstring list;
+  for(auto &id : idlist) {
+    for(signed n = 0; n < size - 16; n++) {
+      if(!memcmp(data + n, (const char*)id.name, id.size)) {
+        const char *p = (const char*)data + n + id.size;
+        if(p[0] >= '0' && p[0] <= '9'
+        && p[1] >= '0' && p[1] <= '9'
+        && p[2] >= '0' && p[2] <= '9'
+        ) {
+          char text[16];
+          memcpy(text, data + n, id.size + 3);
+          text[id.size + 3] = 0;
+          list.appendonce(text);
+        }
+      }
+    }
+  }
+  identifiers = list.concatenate(",");
+
+  markup = "";
+  markup.append("cartridge\n");
+  markup.append("  rom name=program.rom size=0x", hex(size), "\n");
+  if(0);
+  else if(identifiers.beginswith("SRAM_V"    )) markup.append("  ram name=save.ram type=SRAM size=0x8000\n");
+  else if(identifiers.beginswith("SRAM_F_V"  )) markup.append("  ram name=save.ram type=FRAM size=0x8000\n");
+  else if(identifiers.beginswith("EEPROM_V"  )) markup.append("  ram name=save.ram type=EEPROM size=0x0\n");
+  else if(identifiers.beginswith("FLASH_V"   )) markup.append("  ram name=save.ram type=FlashROM size=0x10000\n");
+  else if(identifiers.beginswith("FLASH512_V")) markup.append("  ram name=save.ram type=FlashROM size=0x10000\n");
+  else if(identifiers.beginswith("FLASH1M_V" )) markup.append("  ram name=save.ram type=FlashROM size=0x20000\n");
+//if(identifiers.empty() == false) markup.append("  #detected: ", identifiers, "\n");
+}
+
+}
+
+#endif

ananke/heuristics/game-boy.hpp

@@ -1,11 +1,13 @@
-#ifndef NALL_GAMEBOY_CARTRIDGE_HPP
-#define NALL_GAMEBOY_CARTRIDGE_HPP
+#ifndef NALL_EMULATION_GAME_BOY_HPP
+#define NALL_EMULATION_GAME_BOY_HPP
+
+#include <nall/sha256.hpp>
+#include <nall/string.hpp>
 
 namespace nall {
 
-class GameBoyCartridge {
-public:
-  string xml;
+struct GameBoyCartridge {
+  string markup;
   inline GameBoyCartridge(uint8_t *data, unsigned size);
 
 //private:
@@ -18,11 +20,14 @@ public:
 
     unsigned romsize;
     unsigned ramsize;
+
+    bool cgb;
+    bool cgbonly;
   } info;
 };
 
 GameBoyCartridge::GameBoyCartridge(uint8_t *romdata, unsigned romsize) {
-  xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+  markup = "";
   if(romsize < 0x4000) return;
 
   info.mapper = "unknown";
@@ -48,6 +53,9 @@ GameBoyCartridge::GameBoyCartridge(uint8_t *romdata, unsigned romsize) {
     memcpy(romdata, header, 0x8000);
   }
 
+  info.cgb     = (romdata[0x0143] & 0x80) == 0x80;
+  info.cgbonly = (romdata[0x0143] & 0xc0) == 0xc0;
+
   switch(romdata[0x0147]) {
     case 0x00: info.mapper = "none";  break;
     case 0x01: info.mapper = "MBC1";  break;
@@ -100,18 +108,11 @@ GameBoyCartridge::GameBoyCartridge(uint8_t *romdata, unsigned romsize) {
 
   if(info.mapper == "MBC2") info.ramsize = 512;  //512 x 4-bit
 
-  xml.append("<cartridge mapper='", info.mapper, "'");
-  if(info.rtc) xml.append(" rtc='true'");
-  if(info.rumble) xml.append(" rumble='true'");
-  xml.append(">\n");
-
-  xml.append("  <rom size='", hex(romsize), "'/>\n");  //TODO: trust/check info.romsize?
-
-  if(info.ramsize > 0)
-  xml.append("  <ram size='", hex(info.ramsize), "' battery='", info.battery, "'/>\n");
-
-  xml.append("</cartridge>\n");
-  xml.transform("'", "\"");
+  markup = "";
+  markup.append("cartridge\n");
+  markup.append("  board type=", info.mapper, "\n");
+  markup.append("  rom name=program.rom size=0x", hex(romsize), "\n");
+  if(info.ramsize > 0) markup.append("  ram name=save.ram size=0x", hex(info.ramsize), "\n");
 }
 
 }

ananke/heuristics/satellaview.hpp

@@ -0,0 +1,23 @@
+#ifndef NALL_EMULATION_SATELLAVIEW_HPP
+#define NALL_EMULATION_SATELLAVIEW_HPP
+
+#include <nall/sha256.hpp>
+#include <nall/string.hpp>
+
+namespace nall {
+
+struct SatellaviewCartridge {
+  string markup;
+  inline SatellaviewCartridge(const uint8_t *data, unsigned size);
+};
+
+SatellaviewCartridge::SatellaviewCartridge(const uint8_t *data, unsigned size) {
+  markup = "";
+
+  markup.append("cartridge\n");
+  markup.append("  rom name=program.rom size=0x", hex(size), " type=FlashROM\n");
+}
+
+}
+
+#endif

ananke/heuristics/sufami-turbo.hpp

@@ -0,0 +1,31 @@
+#ifndef NALL_EMULATION_SUFAMI_TURBO_HPP
+#define NALL_EMULATION_SUFAMI_TURBO_HPP
+
+#include <nall/sha256.hpp>
+#include <nall/string.hpp>
+
+namespace nall {
+
+struct SufamiTurboCartridge {
+  string markup;
+  inline SufamiTurboCartridge(const uint8_t *data, unsigned size);
+};
+
+SufamiTurboCartridge::SufamiTurboCartridge(const uint8_t *data, unsigned size) {
+  markup = "";
+
+  if(size < 0x20000) return;  //too small to be a valid game?
+  if(memcmp(data, "BANDAI SFC-ADX", 14)) return;  //missing required header?
+  unsigned romsize = data[0x36] * 0x20000;  //128KB
+  unsigned ramsize = data[0x37] *   0x800;    //2KB
+  bool linkable = data[0x35] != 0x00;  //TODO: unconfirmed
+
+  markup.append("cartridge", linkable ? " linkable" : "", "\n");
+  markup.append("  rom name=program.rom size=0x", hex(romsize), "\n");
+  if(ramsize)
+  markup.append("  ram name=save.ram size=0x", hex(ramsize), "\n");
+}
+
+}
+
+#endif

ananke/heuristics/super-famicom.hpp

@@ -0,0 +1,814 @@
+#ifndef NALL_EMULATION_SUPER_FAMICOM_HPP
+#define NALL_EMULATION_SUPER_FAMICOM_HPP
+
+#include <nall/sha256.hpp>
+#include <nall/string.hpp>
+
+namespace nall {
+
+struct SuperFamicomCartridge {
+  string markup;
+  inline SuperFamicomCartridge(const uint8_t *data, unsigned size);
+
+//private:
+  inline void read_header(const uint8_t *data, unsigned size);
+  inline unsigned find_header(const uint8_t *data, unsigned size);
+  inline unsigned score_header(const uint8_t *data, unsigned size, unsigned addr);
+
+  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 Mode {
+    ModeNormal,
+    ModeBsxSlotted,
+    ModeBsx,
+    ModeSufamiTurbo,
+    ModeSuperGameBoy,
+  };
+
+  enum Type {
+    TypeNormal,
+    TypeBsxSlotted,
+    TypeBsxBios,
+    TypeBsx,
+    TypeSufamiTurboBios,
+    TypeSufamiTurbo,
+    TypeSuperGameBoy1Bios,
+    TypeSuperGameBoy2Bios,
+    TypeGameBoy,
+    TypeUnknown,
+  };
+
+  enum Region {
+    NTSC,
+    PAL,
+  };
+
+  enum MemoryMapper {
+    LoROM,
+    HiROM,
+    ExLoROM,
+    ExHiROM,
+    SuperFXROM,
+    SA1ROM,
+    SPC7110ROM,
+    BSCLoROM,
+    BSCHiROM,
+    BSXROM,
+    STROM,
+  };
+
+  enum DSP1MemoryMapper {
+    DSP1Unmapped,
+    DSP1LoROM1MB,
+    DSP1LoROM2MB,
+    DSP1HiROM,
+  };
+
+  bool loaded;             //is a base cartridge inserted?
+  unsigned crc32;          //crc32 of all cartridges (base+slot(s))
+  unsigned rom_size;
+  unsigned ram_size;
+  bool firmware_appended;  //true if firmware is appended to end of ROM data
+
+  Mode mode;
+  Type type;
+  Region region;
+  MemoryMapper mapper;
+  DSP1MemoryMapper dsp1_mapper;
+
+  bool has_bsx_slot;
+  bool has_superfx;
+  bool has_sa1;
+  bool has_sharprtc;
+  bool has_epsonrtc;
+  bool has_sdd1;
+  bool has_spc7110;
+  bool has_cx4;
+  bool has_dsp1;
+  bool has_dsp2;
+  bool has_dsp3;
+  bool has_dsp4;
+  bool has_obc1;
+  bool has_st010;
+  bool has_st011;
+  bool has_st018;
+};
+
+SuperFamicomCartridge::SuperFamicomCartridge(const uint8_t *data, unsigned size) {
+  firmware_appended = false;
+
+  //skip copier header
+  if((size & 0x7fff) == 512) data += 512, size -= 512;
+
+  markup = "";
+  if(size < 0x8000) return;
+
+  read_header(data, size);
+
+  markup = "";
+  if(type == TypeGameBoy) return;
+  if(type == TypeBsx) return;
+  if(type == TypeSufamiTurbo) return;
+
+  const char *range = (rom_size > 0x200000) || (ram_size > 32 * 1024) ? "0000-7fff" : "0000-ffff";
+  markup.append("cartridge region=", region == NTSC ? "NTSC" : "PAL", "\n");
+
+  if(type == TypeSuperGameBoy1Bios || type == TypeSuperGameBoy2Bios) {
+    markup.append(
+      "  rom name=program.rom size=0x", hex(rom_size), "\n"
+      "  map id=rom address=00-7f,80-ff:8000-ffff mask=0x8000\n"
+      "  icd2 revision=1\n"
+      "    rom name=sgb.boot.rom size=0x100\n"
+      "    map id=io address=00-3f,80-bf:6000-7fff\n"
+    );
+    if((rom_size & 0x7fff) == 0x100) {
+      firmware_appended = true;
+      rom_size -= 0x100;
+    }
+  }
+
+  else if(has_cx4) {
+    markup.append(
+      "  hitachidsp model=HG51B169 frequency=20000000\n"
+      "    rom id=program name=program.rom size=0x", hex(rom_size), "\n"
+      "    rom id=data name=cx4.data.rom size=0xc00\n"
+      "    ram id=data size=0xc00\n"
+      "    map id=io address=00-3f,80-bf:6000-7fff\n"
+      "    map id=rom address=00-7f,80-ff:8000-ffff mask=0x8000\n"
+      "    map id=ram address=70-77:0000-7fff\n"
+    );
+    if((rom_size & 0x7fff) == 0xc00) {
+      firmware_appended = true;
+      rom_size -= 0xc00;
+    }
+  }
+
+  else if(has_spc7110) {
+    markup.append(
+      "  spc7110\n"
+      "    rom id=program name=program.rom size=0x100000\n"
+      "    rom id=data name=data.rom size=0x", hex(rom_size - 0x100000), "\n"
+      "    ram name=save.ram size=0x", hex(ram_size), "\n"
+      "    map id=io address=00-3f,80-bf:4800-483f\n"
+      "    map id=io address=50:0000-ffff\n"
+      "    map id=rom address=00-3f,80-bf:8000-ffff\n"
+      "    map id=rom address=c0-ff:0000-ffff\n"
+      "    map id=ram address=00-3f,80-bf:6000-7fff mask=0xe000\n"
+    );
+  }
+
+  else if(has_sdd1) {
+    markup.append(
+      "  sdd1\n"
+      "    rom name=program.rom size=0x", hex(rom_size), "\n"
+    );
+    if(ram_size > 0) markup.append(
+      "    ram name=save.ram size=0x", hex(ram_size), "\n"
+    );
+    markup.append(
+      "    map id=io address=00-3f,80-bf:4800-4807\n"
+      "    map id=rom address=00-3f,80-bf:8000-ffff mask=0x8000\n"
+      "    map id=rom address=c0-ff:0000-ffff\n"
+    );
+    if(ram_size > 0) markup.append(
+      "    map id=ram address=20-3f,a0-bf:6000-7fff mask=0xe000\n"
+      "    map id=ram address=70-7f:0000-7fff\n"
+    );
+  }
+
+  else if(mapper == LoROM) {
+    markup.append(
+      "  rom name=program.rom size=0x", hex(rom_size), "\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  ram name=save.ram size=0x", hex(ram_size), "\n"
+    );
+    markup.append(
+      "  map id=rom address=00-7f,80-ff:8000-ffff mask=0x8000\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  map id=ram address=70-7f,f0-ff:", range, "\n"
+    );
+  }
+
+  else if(mapper == HiROM) {
+    markup.append(
+      "  rom name=program.rom size=0x", hex(rom_size), "\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  ram name=save.ram size=0x", hex(ram_size), "\n"
+    );
+    markup.append(
+      "  map id=rom address=00-3f,80-bf:8000-ffff\n"
+      "  map id=rom address=40-7f,c0-ff:0000-ffff\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  map id=ram address=10-3f,90-bf:6000-7fff mask=0xe000\n"
+    );
+  }
+
+  else if(mapper == ExLoROM) {
+    markup.append(
+      "  rom name=program.rom size=0x", hex(rom_size), "\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  ram name=save.ram size=0x", hex(ram_size), "\n"
+    );
+    markup.append(
+      "  map id=rom address=00-3f,80-bf:8000-ffff mask=0x8000\n"
+      "  map id=rom address=40-7f:0000-ffff\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  map id=ram address=20-3f,a0-bf:6000-7fff\n"
+      "  map id=ram address=70-7f:0000-7fff\n"
+    );
+  }
+
+  else if(mapper == ExHiROM) {
+    markup.append(
+      "  rom name=program.rom size=0x", hex(rom_size), "\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  ram name=save.ram size=0x", hex(ram_size), "\n"
+    );
+    markup.append(
+      "  map id=rom address=00-3f:8000-ffff base=0x400000\n"
+      "  map id=rom address=40-7f:0000-ffff base=0x400000\n"
+      "  map id=rom address=80-bf:8000-ffff mask=0xc00000\n"
+      "  map id=rom address=c0-ff:0000-ffff mask=0xc00000\n"
+    );
+    if(ram_size > 0) markup.append(
+      "  map id=ram address=20-3f,a0-bf:6000-7fff mask=0xe000\n"
+      "  map id=ram address=70-7f:", range, "\n"
+    );
+  }
+
+  else if(mapper == SuperFXROM) {
+    markup.append(
+      "  superfx revision=3\n"
+      "    rom name=program.rom size=0x", hex(rom_size), "\n"
+    );
+    if(ram_size > 0) markup.append(
+      "    ram name=save.ram size=0x", hex(ram_size), "\n"
+    );
+    markup.append(
+      "    map id=io address=00-3f,80-bf:3000-32ff\n"
+      "    map id=rom address=00-3f,80-bf:8000-ffff mask=0x8000\n"
+      "    map id=rom address=40-5f,c0-df:0000-ffff\n"
+    );
+    if(ram_size > 0) markup.append(
+      "    map id=ram address=00-3f,80-bf:6000-7fff size=0x2000\n"
+      "    map id=ram address=70-71,f0-f1:0000-ffff\n"
+    );
+  }
+
+  else if(mapper == SA1ROM) {
+    markup.append(
+      "  sa1\n"
+      "    rom name=program.rom size=0x", hex(rom_size), "\n"
+    );
+    if(ram_size > 0) markup.append(
+      "    ram id=bitmap name=save.ram size=0x", hex(ram_size), "\n"
+    );
+    markup.append(
+      "    ram id=internal size=0x800\n"
+      "    map id=io address=00-3f,80-bf:2200-23ff\n"
+      "    map id=rom address=00-3f,80-bf:8000-ffff\n"
+      "    map id=rom address=c0-ff:0000-ffff\n"
+    );
+    if(ram_size > 0) markup.append(
+      "    map id=bwram address=00-3f,80-bf:6000-7fff\n"
+      "    map id=bwram address=40-4f:0000-ffff\n"
+    );
+    markup.append(
+      "    map id=iram address=00-3f,80-bf:3000-37ff\n"
+    );
+  }
+
+  else if(mapper == BSCLoROM) {
+    markup.append(
+      "  rom name=program.rom size=0x", hex(rom_size), "\n"
+      "  ram name=save.ram size=0x", hex(ram_size), "\n"
+      "  map id=rom address=00-1f:8000-ffff base=0x000000 mask=0x8000\n"
+      "  map id=rom address=20-3f:8000-ffff base=0x100000 mask=0x8000\n"
+      "  map id=rom address=80-9f:8000-ffff base=0x200000 mask=0x8000\n"
+      "  map id=rom address=a0-bf:8000-ffff base=0x100000 mask=0x8000\n"
+      "  map id=ram address=70-7f,f0-ff:0000-7fff\n"
+      "  bsxslot\n"
+      "    map id=rom address=c0-ef:0000-ffff\n"
+    );
+  }
+
+  else if(mapper == BSCHiROM) {
+    markup.append(
+      "  rom name=program.rom size=0x", hex(rom_size), "\n"
+      "  ram name=save.ram size=0x", hex(ram_size), "\n"
+      "  map id=rom address=00-1f,80-9f:8000-ffff\n"
+      "  map id=rom address=40-5f,c0-df:0000-ffff\n"
+      "  map id=ram address=20-3f,a0-bf:6000-7fff\n"
+      "  bsxslot\n"
+      "    map id=rom address=20-3f,a0-bf:8000-ffff\n"
+      "    map id=rom address=60-7f,e0-ff:0000-ffff\n"
+    );
+  }
+
+  else if(mapper == BSXROM) {
+    markup.append(
+      "  bsx\n"
+      "    rom name=program.rom size=0x", hex(rom_size), "\n"
+      "    ram id=save name=save.ram size=0x", hex(ram_size), "\n"
+      "    ram id=download name=bsx.ram size=0x40000\n"
+      "    map id=io address=00-3f,80-bf:5000-5fff\n"
+      "    map id=rom address=00-3f,80-bf:8000-ffff\n"
+      "    map id=rom address=40-7f,c0-ff:0000-ffff\n"
+      "    map id=ram address=20-3f:6000-7fff\n"
+    );
+  }
+
+  else if(mapper == STROM) {
+    markup.append(
+      "  rom name=program.rom size=0x", hex(rom_size), "\n"
+      "  map id=rom address='00-1f,80-9f:8000-ffff mask=0x8000\n"
+      "  sufamiturbo\n"
+      "    slot id=A\n"
+      "      map id=rom address=20-3f,a0-bf:8000-ffff mask=0x8000\n"
+      "      map id=ram address=60-63,e0-e3:8000-ffff\n"
+      "    slot id=B\n"
+      "      map id=rom address=40-5f,c0-df:8000-ffff mask=0x8000\n"
+      "      map id=ram address=70-73,f0-f3:8000-ffff\n"
+    );
+  }
+
+  if(has_sharprtc) {
+    markup.append(
+      "  sharprtc\n"
+      "    ram name=rtc.ram size=0x10\n"
+      "    map id=io address=00-3f,80-bf:2800-2801\n"
+    );
+  }
+
+  if(has_epsonrtc) {
+    markup.append(
+      "  epsonrtc\n"
+      "    ram name=rtc.ram size=0x10\n"
+      "    map id=io address=00-3f,80-bf:4840-4842\n"
+    );
+  }
+
+  if(has_obc1) {
+    markup.append(
+      "  obc1\n"
+      "    ram name=save.ram size=0x2000\n"
+      "    map id=io address=00-3f,80-bf:6000-7fff\n"
+    );
+  }
+
+  if(has_dsp1) {
+    markup.append(
+      "  necdsp model=uPD7725 frequency=8000000\n"
+      "    rom id=program name=dsp1b.program.rom size=0x1800\n"
+      "    rom id=data name=dsp1b.data.rom size=0x800\n"
+      "    ram id=data size=0x200\n"
+    );
+    if(dsp1_mapper == DSP1LoROM1MB) markup.append(
+      "    map id=io address=20-3f,a0-bf:8000-ffff select=0x4000\n"
+    );
+    if(dsp1_mapper == DSP1LoROM2MB) markup.append(
+      "    map id=io address=60-6f,e0-ef:0000-7fff select=0x4000\n"
+    );
+    if(dsp1_mapper == DSP1HiROM) markup.append(
+      "    map id=io address=00-1f,80-9f:6000-7fff select=0x1000\n"
+    );
+    if((size & 0x7fff) == 0x2000) {
+      firmware_appended = true;
+      rom_size -= 0x2000;
+    }
+  }
+
+  if(has_dsp2) {
+    markup.append(
+      "  necdsp model=uPD7725 frequency=8000000\n"
+      "    rom id=program name=dsp2.program.rom size=0x1800\n"
+      "    rom id=data name=dsp2.data.rom size=0x800\n"
+      "    ram id=data size=0x200\n"
+      "    map id=io address=20-3f,a0-bf:8000-ffff select=0x4000\n"
+    );
+    if((size & 0x7fff) == 0x2000) {
+      firmware_appended = true;
+      rom_size -= 0x2000;
+    }
+  }
+
+  if(has_dsp3) {
+    markup.append(
+      "  necdsp model=uPD7725 frequency=8000000\n"
+      "    rom id=program name=dsp3.program.rom size=0x1800\n"
+      "    rom id=data name=dsp3.data.rom size=0x800\n"
+      "    ram id=data size=0x200\n"
+      "    map id=io address=20-3f,a0-bf:8000-ffff select=0x4000\n"
+    );
+    if((size & 0x7fff) == 0x2000) {
+      firmware_appended = true;
+      rom_size -= 0x2000;
+    }
+  }
+
+  if(has_dsp4) {
+    markup.append(
+      "  necdsp model=uPD7725 frequency=8000000\n"
+      "    rom id=program name=dsp4.program.rom size=0x1800\n"
+      "    rom id=data name=dsp4.data.rom size=0x800\n"
+      "    ram id=data size=0x200\n"
+      "    map id=io address=30-3f,b0-bf:8000-ffff select=0x4000\n"
+    );
+    if((size & 0x7fff) == 0x2000) {
+      firmware_appended = true;
+      rom_size -= 0x2000;
+    }
+  }
+
+  if(has_st010) {
+    markup.append(
+      "  necdsp model=uPD96050 frequency=11000000\n"
+      "    rom id=program name=st010.program.rom size=0xc000\n"
+      "    rom id=data name=st010.data.rom size=0x1000\n"
+      "    ram id=data name=save.ram size=0x1000\n"
+      "    map id=io address=60-67,e0-e7:0000-3fff select=0x0001\n"
+      "    map id=ram address=68-6f,e8-ef:0000-7fff\n"
+    );
+    if((size & 0xffff) == 0xd000) {
+      firmware_appended = true;
+      rom_size -= 0xd000;
+    }
+  }
+
+  if(has_st011) {
+    markup.append(
+      "  necdsp model=uPD96050 frequency=15000000\n"
+      "    rom id=program name=st011.program.rom size=0xc000\n"
+      "    rom id=data name=st011.data.rom size=0x1000\n"
+      "    ram id=data name=save.ram size=0x1000\n"
+      "    map id=io address=60-67,e0-e7:0000-3fff select=0x0001\n"
+      "    map id=ram address=68-6f,e8-ef:0000-7fff\n"
+    );
+    if((size & 0xffff) == 0xd000) {
+      firmware_appended = true;
+      rom_size -= 0xd000;
+    }
+  }
+
+  if(has_st018) {
+    markup.append(
+      "  armdsp frequency=21477272\n"
+      "    rom id=program name=st018.program.rom size=0x20000\n"
+      "    rom id=data name=st018.data.rom size=0x8000\n"
+      "    ram name=save.ram size=0x4000\n"
+      "    map id=io address=00-3f,80-bf:3800-38ff\n"
+    );
+    if((size & 0x3ffff) == 0x28000) {
+      firmware_appended = true;
+      rom_size -= 0x28000;
+    }
+  }
+}
+
+void SuperFamicomCartridge::read_header(const uint8_t *data, unsigned size) {
+  type        = TypeUnknown;
+  mapper      = LoROM;
+  dsp1_mapper = DSP1Unmapped;
+  region      = NTSC;
+  rom_size    = size;
+  ram_size    = 0;
+
+  has_bsx_slot   = false;
+  has_superfx    = false;
+  has_sa1        = false;
+  has_sharprtc   = false;
+  has_epsonrtc   = false;
+  has_sdd1       = false;
+  has_spc7110    = false;
+  has_cx4        = false;
+  has_dsp1       = false;
+  has_dsp2       = false;
+  has_dsp3       = false;
+  has_dsp4       = false;
+  has_obc1       = false;
+  has_st010      = false;
+  has_st011      = false;
+  has_st018      = false;
+
+  //=====================
+  //detect Game Boy carts
+  //=====================
+
+  if(size >= 0x0140) {
+    if(data[0x0104] == 0xce && data[0x0105] == 0xed && data[0x0106] == 0x66 && data[0x0107] == 0x66
+    && data[0x0108] == 0xcc && data[0x0109] == 0x0d && data[0x010a] == 0x00 && data[0x010b] == 0x0b) {
+      type = TypeGameBoy;
+      return;
+    }
+  }
+
+  if(size < 32768) {
+    type = TypeUnknown;
+    return;
+  }
+
+  const unsigned index = find_header(data, size);
+  const uint8_t mapperid = data[index + Mapper];
+  const uint8_t rom_type = data[index + RomType];
+  const uint8_t rom_size = data[index + RomSize];
+  const uint8_t company  = data[index + Company];
+  const uint8_t regionid = data[index + CartRegion] & 0x7f;
+
+  ram_size = 1024 << (data[index + RamSize] & 7);
+  if(ram_size == 1024) ram_size = 0;  //no RAM present
+  if(rom_size == 0 && ram_size) ram_size = 0;  //fix for Bazooka Blitzkrieg's malformed header (swapped ROM and RAM sizes)
+
+  //0, 1, 13 = NTSC; 2 - 12 = PAL
+  region = (regionid <= 1 || regionid >= 13) ? NTSC : PAL;
+
+  //=======================
+  //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) {
+          type = TypeBsx;
+          mapper = BSXROM;
+          region = NTSC;  //BS-X only released in Japan
+          return;
+        }
+      }
+    }
+  }
+
+  //=========================
+  //detect Sufami Turbo carts
+  //=========================
+
+  if(!memcmp(data, "BANDAI SFC-ADX", 14)) {
+    if(!memcmp(data + 16, "SFC-ADX BACKUP", 14)) {
+      type = TypeSufamiTurboBios;
+    } else {
+      type = TypeSufamiTurbo;
+    }
+    mapper = STROM;
+    region = NTSC;  //Sufami Turbo only released in Japan
+    return;         //RAM size handled outside this routine
+  }
+
+  //==========================
+  //detect Super Game Boy BIOS
+  //==========================
+
+  if(!memcmp(data + index, "Super GAMEBOY2", 14)) {
+    type = TypeSuperGameBoy2Bios;
+    return;
+  }
+
+  if(!memcmp(data + index, "Super GAMEBOY", 13)) {
+    type = TypeSuperGameBoy1Bios;
+    return;
+  }
+
+  //=====================
+  //detect standard carts
+  //=====================
+
+  //detect presence of BS-X flash cartridge connector (reads extended header information)
+  if(data[index - 14] == 'Z') {
+    if(data[index - 11] == 'J') {
+      uint8_t n13 = data[index - 13];
+      if((n13 >= 'A' && n13 <= 'Z') || (n13 >= '0' && n13 <= '9')) {
+        if(company == 0x33 || (data[index - 10] == 0x00 && data[index - 4] == 0x00)) {
+          has_bsx_slot = true;
+        }
+      }
+    }
+  }
+
+  if(has_bsx_slot) {
+    if(!memcmp(data + index, "Satellaview BS-X     ", 21)) {
+      //BS-X base cart
+      type = TypeBsxBios;
+      mapper = BSXROM;
+      region = NTSC;  //BS-X only released in Japan
+      return;         //RAM size handled internally by load_cart_bsx() -> BSXCart class
+    } else {
+      type = TypeBsxSlotted;
+      mapper = (index == 0x7fc0 ? BSCLoROM : BSCHiROM);
+      region = NTSC;  //BS-X slotted cartridges only released in Japan
+    }
+  } else {
+    //standard cart
+    type = TypeNormal;
+
+    if(index == 0x7fc0 && size >= 0x401000) {
+      mapper = ExLoROM;
+    } else if(index == 0x7fc0 && mapperid == 0x32) {
+      mapper = ExLoROM;
+    } else if(index == 0x7fc0) {
+      mapper = LoROM;
+    } else if(index == 0xffc0) {
+      mapper = HiROM;
+    } else {  //index == 0x40ffc0
+      mapper = ExHiROM;
+    }
+  }
+
+  if(mapperid == 0x20 && (rom_type == 0x13 || rom_type == 0x14 || rom_type == 0x15 || rom_type == 0x1a)) {
+    has_superfx = true;
+    mapper = SuperFXROM;
+    ram_size = 1024 << (data[index - 3] & 7);
+    if(ram_size == 1024) ram_size = 0;
+  }
+
+  if(mapperid == 0x23 && (rom_type == 0x32 || rom_type == 0x34 || rom_type == 0x35)) {
+    has_sa1 = true;
+    mapper = SA1ROM;
+  }
+
+  if(mapperid == 0x35 && rom_type == 0x55) {
+    has_sharprtc = true;
+  }
+
+  if(mapperid == 0x32 && (rom_type == 0x43 || rom_type == 0x45)) {
+    has_sdd1 = true;
+  }
+
+  if(mapperid == 0x3a && (rom_type == 0xf5 || rom_type == 0xf9)) {
+    has_spc7110 = true;
+    has_epsonrtc = (rom_type == 0xf9);
+    mapper = SPC7110ROM;
+  }
+
+  if(mapperid == 0x20 && rom_type == 0xf3) {
+    has_cx4 = true;
+  }
+
+  if((mapperid == 0x20 || mapperid == 0x21) && rom_type == 0x03) {
+    has_dsp1 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x05 && company != 0xb2) {
+    has_dsp1 = true;
+  }
+
+  if(mapperid == 0x31 && (rom_type == 0x03 || rom_type == 0x05)) {
+    has_dsp1 = true;
+  }
+
+  if(has_dsp1 == true) {
+    if((mapperid & 0x2f) == 0x20 && size <= 0x100000) {
+      dsp1_mapper = DSP1LoROM1MB;
+    } else if((mapperid & 0x2f) == 0x20) {
+      dsp1_mapper = DSP1LoROM2MB;
+    } else if((mapperid & 0x2f) == 0x21) {
+      dsp1_mapper = DSP1HiROM;
+    }
+  }
+
+  if(mapperid == 0x20 && rom_type == 0x05) {
+    has_dsp2 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x05 && company == 0xb2) {
+    has_dsp3 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x03) {
+    has_dsp4 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x25) {
+    has_obc1 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0xf6 && rom_size >= 10) {
+    has_st010 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0xf6 && rom_size < 10) {
+    has_st011 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0xf5) {
+    has_st018 = true;
+  }
+}
+
+unsigned SuperFamicomCartridge::find_header(const uint8_t *data, unsigned size) {
+  unsigned score_lo = score_header(data, size, 0x007fc0);
+  unsigned score_hi = score_header(data, size, 0x00ffc0);
+  unsigned score_ex = score_header(data, size, 0x40ffc0);
+  if(score_ex) score_ex += 4;  //favor ExHiROM on images > 32mbits
+
+  if(score_lo >= score_hi && score_lo >= score_ex) {
+    return 0x007fc0;
+  } else if(score_hi >= score_ex) {
+    return 0x00ffc0;
+  } else {
+    return 0x40ffc0;
+  }
+}
+
+unsigned SuperFamicomCartridge::score_header(const uint8_t *data, unsigned size, unsigned addr) {
+  if(size < addr + 64) return 0;  //image too small to contain header at this location?
+  int score = 0;
+
+  uint16_t resetvector = data[addr + ResetVector] | (data[addr + ResetVector + 1] << 8);
+  uint16_t checksum    = data[addr + Checksum   ] | (data[addr + Checksum    + 1] << 8);
+  uint16_t complement  = data[addr + Complement ] | (data[addr + Complement  + 1] << 8);
+
+  uint8_t resetop = data[(addr & ~0x7fff) | (resetvector & 0x7fff)];  //first opcode executed upon reset
+  uint8_t 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.
+  if(resetvector < 0x8000) return 0;
+
+  //some images duplicate the header in multiple locations, and others have completely
+  //invalid header information that cannot be relied upon.
+  //below code will analyze the first opcode executed at the specified reset vector to
+  //determine the probability that this is the correct header.
+
+  //most likely opcodes
+  if(resetop == 0x78  //sei
+  || resetop == 0x18  //clc (clc; xce)
+  || resetop == 0x38  //sec (sec; xce)
+  || resetop == 0x9c  //stz $nnnn (stz $4200)
+  || resetop == 0x4c  //jmp $nnnn
+  || resetop == 0x5c  //jml $nnnnnn
+  ) score += 8;
+
+  //plausible opcodes
+  if(resetop == 0xc2  //rep #$nn
+  || resetop == 0xe2  //sep #$nn
+  || resetop == 0xad  //lda $nnnn
+  || resetop == 0xae  //ldx $nnnn
+  || resetop == 0xac  //ldy $nnnn
+  || resetop == 0xaf  //lda $nnnnnn
+  || resetop == 0xa9  //lda #$nn
+  || resetop == 0xa2  //ldx #$nn
+  || resetop == 0xa0  //ldy #$nn
+  || resetop == 0x20  //jsr $nnnn
+  || resetop == 0x22  //jsl $nnnnnn
+  ) score += 4;
+
+  //implausible opcodes
+  if(resetop == 0x40  //rti
+  || resetop == 0x60  //rts
+  || resetop == 0x6b  //rtl
+  || resetop == 0xcd  //cmp $nnnn
+  || resetop == 0xec  //cpx $nnnn
+  || resetop == 0xcc  //cpy $nnnn
+  ) score -= 4;
+
+  //least likely opcodes
+  if(resetop == 0x00  //brk #$nn
+  || resetop == 0x02  //cop #$nn
+  || resetop == 0xdb  //stp
+  || resetop == 0x42  //wdm
+  || resetop == 0xff  //sbc $nnnnnn,x
+  ) score -= 8;
+
+  //at times, both the header and reset vector's first opcode will match ...
+  //fallback and rely on info validity in these cases to determine more likely header.
+
+  //a valid checksum is the biggest indicator of a valid header.
+  if((checksum + complement) == 0xffff && (checksum != 0) && (complement != 0)) score += 4;
+
+  if(addr == 0x007fc0 && mapper == 0x20) score += 2;  //0x20 is usually LoROM
+  if(addr == 0x00ffc0 && mapper == 0x21) score += 2;  //0x21 is usually HiROM
+  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 + RomType] < 0x08) score++;
+  if(data[addr + RomSize] < 0x10) score++;
+  if(data[addr + RamSize] < 0x08) score++;
+  if(data[addr + CartRegion] < 14) score++;
+
+  if(score < 0) score = 0;
+  return score;
+}
+
+}
+
+#endif

ananke/obj/.gitignore

@@ -0,0 +1 @@
+*.o

ananke/patch.cpp

@@ -0,0 +1,15 @@
+void Ananke::applyBeatPatch(vector<uint8_t> &buffer) {
+  string name = {information.path, nall::basename(information.name), ".bps"};
+  if(!file::exists(name)) return;
+
+  bpspatch patch;
+  if(patch.modify(name) == false) return;
+  patch.source(buffer.data(), buffer.size());
+  vector<uint8_t> output;
+  output.resize(patch.size());
+  patch.target(output.data(), output.size());
+  if(patch.apply() == bpspatch::result::success) {
+    buffer = output;
+    information.manifest = patch.metadata();
+  }
+}

ananke/resource/resource.bml

@@ -0,0 +1,6 @@
+resource name=resource
+  binary id=home name=home.png
+  binary id=up name=up.png
+  binary id=folder name=folder.png
+  binary id=file name=file.png
+  binary id=archive name=archive.png

ananke/resource/resource.cpp

@@ -0,0 +1,156 @@
+namespace resource {
+
+const uint8_t home[606] = {
+  137,80,78,71,13,10,26,10,0,0,0,13,73,72,68,82,0,0,0,16,0,0,0,16,8,6,0,0,0,31,243,255,
+  97,0,0,0,6,98,75,71,68,0,0,0,0,0,0,249,67,187,127,0,0,0,9,112,72,89,115,0,0,13,215,0,
+  0,13,215,1,66,40,155,120,0,0,0,7,116,73,77,69,7,213,10,14,20,37,19,83,42,210,59,0,0,1,235,73,
+  68,65,84,56,203,149,147,191,107,83,81,20,128,191,123,251,222,75,211,64,242,36,160,85,135,100,81,123,19,104,85,172,
+  17,92,28,140,66,19,167,135,212,74,39,145,162,163,24,92,58,180,110,193,169,254,24,234,212,37,139,245,199,96,19,240,
+  15,240,63,16,121,91,92,196,90,219,240,98,81,137,33,121,215,33,246,217,151,80,33,103,186,92,206,247,221,115,14,231,
+  194,1,225,41,85,172,128,174,128,246,148,122,200,48,177,7,123,74,105,79,169,61,73,113,104,120,177,56,163,203,55,111,
+  252,87,34,250,225,154,235,110,20,148,98,253,220,89,182,39,78,113,228,240,56,39,188,38,83,107,107,212,92,151,130,82,
+  215,14,185,110,117,64,176,31,126,83,156,97,247,248,49,148,202,50,22,141,210,106,181,24,219,252,74,182,92,30,144,136,
+  126,184,122,251,22,157,100,146,116,42,77,42,149,2,64,107,104,183,219,236,214,235,156,44,149,66,18,177,31,126,247,160,
+  68,199,48,201,229,46,96,219,118,208,154,214,26,0,223,247,249,185,181,69,114,110,46,144,136,10,232,130,82,188,127,84,
+  198,107,54,57,63,157,35,30,143,35,132,8,9,124,223,15,206,134,16,140,230,243,212,92,23,3,184,3,172,78,157,62,
+  195,253,210,61,54,170,111,3,240,201,202,51,86,30,63,69,139,17,116,167,133,48,70,209,221,223,44,47,45,209,238,165,
+  204,202,121,120,190,48,153,33,17,79,0,160,212,4,153,140,34,155,205,244,94,20,146,145,244,149,222,196,83,121,144,22,
+  90,107,22,38,51,204,195,186,236,239,211,178,44,76,211,196,48,140,224,254,75,227,7,0,31,234,59,116,187,126,144,11,
+  48,32,144,82,34,165,196,146,159,1,232,96,241,241,83,3,128,111,222,47,58,34,18,90,36,99,96,179,254,14,207,231,
+  40,0,151,46,78,115,53,26,67,234,113,46,75,147,237,77,66,21,24,253,21,252,155,126,239,165,239,222,14,162,217,56,
+  112,245,3,65,36,18,193,182,109,18,137,4,2,137,16,16,139,197,112,28,103,0,178,44,43,252,23,174,207,58,175,0,
+  135,225,98,245,229,139,215,119,255,0,86,248,213,163,133,187,128,26,0,0,0,0,73,69,78,68,174,66,96,130,
+};
+
+const uint8_t up[652] = {
+  137,80,78,71,13,10,26,10,0,0,0,13,73,72,68,82,0,0,0,16,0,0,0,16,8,6,0,0,0,31,243,255,
+  97,0,0,0,4,115,66,73,84,8,8,8,8,124,8,100,136,0,0,0,25,116,69,88,116,83,111,102,116,119,97,114,
+  101,0,119,119,119,46,105,110,107,115,99,97,112,101,46,111,114,103,155,238,60,26,0,0,2,30,73,68,65,84,56,141,
+  149,147,79,104,19,65,20,198,191,55,187,51,217,141,133,122,104,76,255,209,130,4,237,193,64,42,168,208,213,138,104,68,
+  98,69,45,20,114,107,74,201,73,144,98,22,193,171,199,82,145,160,23,15,69,79,30,165,66,241,226,77,42,94,68,80,
+  208,67,41,180,42,149,148,52,137,166,154,38,217,217,25,15,81,172,33,169,246,29,223,251,230,199,124,223,155,33,173,53,
+  218,213,201,155,124,30,0,150,102,189,233,118,26,214,110,224,184,60,221,223,21,73,246,117,29,76,58,46,79,239,9,224,
+  184,60,26,16,251,178,87,206,76,6,199,70,147,193,128,8,102,29,151,71,255,11,224,184,188,3,132,197,137,115,211,214,
+  150,151,199,150,183,137,248,200,37,11,132,69,199,229,29,255,4,16,225,209,232,112,162,167,55,52,72,159,75,31,240,177,
+  244,30,157,157,157,20,27,58,209,13,194,195,93,1,142,203,211,253,7,34,137,179,71,199,249,74,254,13,12,198,97,50,
+  142,87,107,11,136,13,29,23,161,253,61,137,230,60,216,142,195,81,193,237,108,42,225,218,235,229,101,104,242,32,132,137,
+  58,125,199,54,21,241,46,255,28,23,78,95,13,154,166,248,43,15,182,211,247,212,88,198,82,228,161,34,75,16,1,1,
+  30,224,40,203,117,8,219,64,65,174,162,168,86,113,254,212,69,139,216,159,60,216,111,223,241,99,227,221,135,250,98,148,
+  175,172,193,228,6,56,55,80,81,5,84,141,175,16,54,131,176,25,150,191,189,64,184,55,68,71,14,15,135,137,53,242,
+  160,145,140,153,30,232,142,100,111,76,220,177,5,15,64,65,194,135,135,215,185,5,188,45,60,131,100,21,16,35,36,6,
+  50,208,90,67,41,160,94,175,225,241,211,249,74,177,180,57,99,18,67,234,83,110,197,158,185,119,185,225,137,163,122,247,
+  250,19,171,44,115,240,141,109,112,193,192,76,130,193,9,115,15,110,87,101,77,91,191,236,7,137,33,101,46,205,122,78,
+  211,38,180,214,10,165,250,23,48,131,96,112,6,30,104,64,100,77,91,47,231,60,218,245,29,0,128,210,62,126,212,139,
+  141,43,251,26,178,174,160,85,235,63,99,182,106,250,74,162,90,219,134,50,53,160,21,124,73,240,189,61,0,164,47,17,
+  31,188,6,98,0,49,2,17,246,0,32,108,220,186,63,25,110,37,38,194,70,115,239,39,48,247,197,219,182,208,154,34,
+  0,0,0,0,73,69,78,68,174,66,96,130,
+};
+
+const uint8_t folder[1176] = {
+  137,80,78,71,13,10,26,10,0,0,0,13,73,72,68,82,0,0,0,32,0,0,0,32,8,6,0,0,0,115,122,122,
+  244,0,0,0,4,115,66,73,84,8,8,8,8,124,8,100,136,0,0,0,9,112,72,89,115,0,0,13,215,0,0,13,
+  215,1,66,40,155,120,0,0,0,25,116,69,88,116,83,111,102,116,119,97,114,101,0,119,119,119,46,105,110,107,115,99,
+  97,112,101,46,111,114,103,155,238,60,26,0,0,4,21,73,68,65,84,88,133,237,151,61,111,28,69,24,199,127,51,187,
+  119,123,175,246,57,145,48,9,5,86,148,194,31,0,9,5,33,83,110,149,130,26,137,2,90,58,62,64,36,62,64,74,
+  132,68,133,104,161,67,72,167,64,23,201,138,2,138,210,69,194,198,196,40,22,198,247,186,119,222,151,153,157,25,138,123,
+  201,58,119,142,19,114,82,40,248,75,143,118,118,118,247,121,126,243,60,51,179,187,34,12,67,94,167,228,107,141,254,95,
+  0,240,1,110,220,184,225,43,165,126,54,198,188,119,209,3,66,136,220,90,251,249,195,135,15,191,92,25,64,154,166,91,
+  149,74,229,157,155,55,111,250,73,146,224,156,3,192,90,11,48,63,159,182,253,59,119,238,220,222,222,222,254,254,209,163,
+  71,199,43,1,80,74,101,213,106,213,29,29,29,209,233,116,112,206,45,53,0,33,4,155,155,155,249,193,193,193,71,192,
+  237,149,0,104,173,211,44,203,196,165,75,27,24,99,176,214,158,9,92,204,132,16,130,106,181,90,63,60,60,252,98,123,
+  123,251,214,172,127,153,156,115,218,90,251,241,222,222,222,143,207,5,0,178,44,203,188,78,167,75,167,211,153,3,204,142,
+  179,32,197,64,91,91,91,245,70,163,65,179,217,68,8,129,16,2,0,41,229,188,29,69,17,247,238,221,187,5,60,31,
+  224,242,229,203,105,191,223,247,54,54,90,104,173,23,0,150,149,98,166,56,142,1,230,16,69,139,227,24,99,76,237,188,
+  224,115,128,221,221,93,117,237,218,53,217,235,245,230,25,0,150,130,204,178,81,212,108,196,197,224,82,202,25,64,229,66,
+  0,0,99,140,109,54,215,100,154,102,220,63,180,220,221,63,27,228,188,58,63,171,25,204,228,153,22,206,93,185,206,219,
+  31,232,226,61,158,39,190,93,255,253,155,79,206,0,56,231,116,183,219,245,187,221,46,143,59,13,62,253,240,93,174,191,
+  181,81,112,54,61,62,47,250,18,200,105,207,60,206,147,206,152,175,190,187,255,254,236,188,152,1,221,104,212,171,90,107,
+  212,31,146,102,181,204,254,223,99,162,56,159,140,108,233,104,207,35,17,11,77,1,52,42,62,42,211,8,65,103,118,121,
+  190,21,27,99,116,191,63,160,219,237,18,103,150,122,181,132,53,147,27,228,212,193,179,134,59,207,220,83,179,19,179,214,
+  145,100,134,52,203,193,137,249,6,86,44,65,86,169,4,180,90,45,50,35,168,5,37,172,83,120,114,53,175,139,113,154,
+  83,111,250,140,134,57,214,186,39,11,0,121,158,171,40,26,209,239,15,208,230,13,170,129,143,115,14,79,158,155,231,23,
+  147,131,81,170,209,185,37,240,37,113,170,173,49,249,209,2,128,49,38,43,151,75,84,155,27,172,213,202,56,64,10,177,
+  188,248,47,40,227,28,163,84,147,91,135,231,9,130,178,199,105,146,41,33,196,201,2,128,181,54,27,141,198,28,15,20,
+  235,245,75,232,220,190,210,232,51,109,137,51,3,78,224,79,253,148,61,201,232,84,229,130,167,147,176,152,129,212,247,125,
+  188,32,160,73,153,76,217,11,131,76,230,152,195,186,201,62,97,236,196,84,110,151,173,72,156,131,193,40,181,185,115,139,
+  0,214,218,100,60,30,211,25,248,84,90,101,162,68,147,233,233,75,8,200,141,69,27,135,206,45,185,153,110,203,47,153,
+  149,68,25,134,227,196,19,210,91,90,130,84,8,129,12,26,148,74,62,163,68,19,37,154,84,25,148,182,47,29,108,153,
+  226,44,231,52,209,62,231,148,32,142,227,83,122,81,133,74,13,30,159,196,12,99,189,212,209,191,145,0,134,177,66,25,
+  83,250,245,234,94,47,124,252,12,128,181,54,6,129,245,107,100,185,37,138,53,74,95,60,15,94,84,82,10,78,134,9,
+  82,200,56,220,221,157,59,62,51,7,146,36,33,74,12,87,175,4,84,3,143,160,188,186,111,86,41,4,105,170,144,82,
+  12,139,253,197,18,36,0,154,18,235,85,143,122,105,21,85,127,42,231,28,253,36,65,88,59,88,0,104,183,219,98,103,
+  103,199,68,177,98,112,234,248,243,100,136,236,190,226,14,184,68,199,199,67,155,36,195,7,187,237,118,45,12,195,120,14,
+  0,120,81,20,253,244,203,161,248,76,173,227,255,182,255,202,31,187,103,228,192,2,88,157,30,28,63,248,225,235,226,53,
+  49,251,53,107,183,219,205,96,109,237,205,90,208,218,116,56,41,133,92,201,18,200,141,49,42,75,107,185,16,121,62,58,
+  233,1,127,133,97,216,91,0,152,66,72,32,96,146,153,124,21,0,83,5,64,10,168,48,12,207,44,45,241,255,207,233,
+  235,6,248,7,188,50,165,151,203,8,55,43,0,0,0,0,73,69,78,68,174,66,96,130,
+};
+
+const uint8_t file[844] = {
+  137,80,78,71,13,10,26,10,0,0,0,13,73,72,68,82,0,0,0,32,0,0,0,32,8,6,0,0,0,115,122,122,
+  244,0,0,0,4,115,66,73,84,8,8,8,8,124,8,100,136,0,0,3,3,73,68,65,84,88,133,229,151,79,110,212,
+  48,24,197,127,182,227,56,81,39,116,36,132,0,169,167,226,2,101,209,93,239,192,150,37,171,46,43,245,4,92,164,183,
+  40,82,89,21,36,134,84,76,18,59,44,90,91,142,243,103,50,21,59,62,201,138,227,120,236,247,189,247,252,37,3,255,
+  123,136,116,224,234,234,234,67,150,101,55,64,165,148,66,74,137,115,14,107,109,104,93,215,133,107,220,95,26,3,118,93,
+  215,125,188,185,185,249,26,239,151,141,16,9,113,125,113,113,81,61,247,195,120,223,247,131,121,241,253,202,126,117,121,121,
+  121,13,44,3,176,214,110,1,110,111,111,17,66,32,165,12,87,41,37,74,41,148,82,8,33,80,74,177,221,110,209,90,
+  15,158,167,125,33,4,251,253,158,166,105,182,233,126,50,29,232,251,30,33,68,104,64,88,208,55,207,78,215,117,24,99,
+  70,191,247,109,77,140,24,112,206,133,13,98,6,210,38,165,164,40,138,48,127,42,60,16,159,200,20,168,17,3,206,185,
+  17,11,177,4,49,40,231,28,77,211,28,204,114,137,141,17,0,107,109,232,207,177,224,159,41,165,208,90,31,100,97,9,
+  200,36,3,233,230,233,189,181,150,60,207,41,203,146,186,174,233,186,46,204,91,202,124,21,0,207,192,156,9,1,140,49,
+  20,69,65,93,215,100,89,70,158,231,3,173,231,50,127,17,128,88,123,127,239,105,55,198,96,140,161,109,219,85,174,95,
+  13,96,202,132,41,35,62,218,182,5,240,213,110,113,211,163,25,72,179,23,66,208,52,13,90,235,80,92,252,243,199,199,
+  199,229,244,97,210,172,7,37,136,93,47,165,164,170,42,178,44,67,8,193,201,201,73,232,151,101,57,152,63,197,194,139,
+  37,136,77,168,181,198,90,27,42,97,215,117,97,222,210,113,92,205,128,215,50,205,222,103,16,75,226,156,11,12,120,64,
+  62,203,41,38,142,146,32,213,190,239,123,172,181,225,69,228,105,143,193,214,117,141,115,110,86,134,163,0,196,11,11,33,
+  200,178,140,170,170,6,115,235,186,14,114,120,79,40,165,70,155,28,205,64,74,181,7,32,165,28,248,195,24,67,158,231,
+  1,172,82,106,117,89,158,5,144,158,231,212,7,113,40,165,6,12,120,169,210,170,184,20,171,142,161,47,54,177,254,254,
+  236,123,205,227,58,177,219,237,86,3,152,250,34,26,80,37,132,96,179,217,80,150,229,200,96,155,205,6,173,245,96,190,
+  49,38,48,177,6,196,162,9,189,15,178,44,27,140,123,96,109,219,142,36,136,95,90,107,98,214,3,177,9,211,240,99,
+  190,8,77,197,161,162,52,11,32,149,96,238,37,3,79,18,164,0,60,232,135,135,135,17,107,171,1,132,135,82,6,157,
+  227,240,0,119,187,221,8,160,63,5,167,167,167,65,138,163,62,201,226,5,189,235,167,88,232,251,30,173,245,36,56,95,
+  71,252,247,229,82,164,167,160,146,82,254,234,251,254,213,217,217,89,24,156,211,185,40,138,197,197,211,242,155,231,249,14,
+  120,7,252,4,246,41,128,10,120,115,127,127,255,249,252,252,252,19,80,46,174,190,50,242,60,167,105,26,132,16,127,238,
+  238,238,190,0,239,1,5,124,7,92,156,90,14,188,5,94,3,91,192,60,79,252,23,241,135,167,100,107,224,7,240,13,
+  248,13,19,127,78,159,55,46,158,1,173,43,103,135,195,1,45,79,180,239,129,96,140,191,182,58,238,12,241,249,173,246,
+  0,0,0,0,73,69,78,68,174,66,96,130,
+};
+
+const uint8_t archive[1067] = {
+  137,80,78,71,13,10,26,10,0,0,0,13,73,72,68,82,0,0,0,32,0,0,0,32,8,6,0,0,0,115,122,122,
+  244,0,0,0,4,115,66,73,84,8,8,8,8,124,8,100,136,0,0,3,226,73,68,65,84,88,133,237,150,95,136,212,
+  85,20,199,63,231,222,251,251,253,102,102,103,255,142,166,27,150,150,88,144,102,127,31,218,40,49,200,36,136,68,200,30,
+  20,218,212,13,89,84,8,138,30,138,222,10,122,232,205,212,44,89,55,145,192,146,32,168,232,37,42,208,212,84,212,165,
+  32,162,168,101,21,203,221,213,253,51,237,56,51,191,223,189,61,252,134,217,217,117,86,155,26,240,161,253,194,225,222,115,
+  239,253,157,251,189,231,158,223,57,23,102,49,139,255,59,228,90,147,189,47,164,151,26,63,120,51,12,243,107,156,184,60,
+  14,59,229,75,135,2,130,234,70,5,45,114,196,89,121,233,185,247,198,142,215,68,96,223,150,166,37,126,144,58,168,148,
+  190,115,249,163,107,82,205,109,237,68,81,136,32,24,63,0,229,163,76,2,209,1,202,76,138,232,4,202,11,80,58,32,
+  180,206,253,240,117,143,244,159,250,232,47,27,113,209,138,125,165,115,87,246,208,117,9,236,239,106,190,77,18,254,137,101,
+  43,58,91,231,45,186,67,141,12,156,117,103,15,127,38,78,0,231,112,81,30,163,4,163,193,211,130,209,130,167,193,76,
+  235,39,146,45,100,30,123,195,93,56,190,215,133,131,167,213,207,231,70,115,69,203,182,141,239,142,247,84,238,167,43,149,
+  3,93,201,5,36,147,199,239,93,221,221,182,248,129,213,122,252,66,31,167,191,249,88,10,133,43,216,40,196,218,8,37,
+  160,68,80,10,180,18,148,18,180,2,53,173,47,46,79,225,242,79,114,83,199,139,146,255,227,20,173,137,208,27,30,203,
+  175,122,250,65,51,240,233,201,98,223,85,30,120,191,171,97,94,50,149,60,185,108,229,166,246,246,37,29,218,141,253,138,
+  23,52,80,140,38,157,100,157,5,107,65,25,68,123,177,168,88,40,181,162,13,136,46,27,78,54,207,167,144,27,167,175,
+  119,45,162,52,191,93,24,155,112,214,110,234,220,147,61,88,38,208,179,49,61,55,104,76,29,107,91,176,116,161,56,114,
+  67,3,125,233,71,158,121,141,230,185,183,146,27,57,55,121,95,162,64,52,136,138,5,13,74,226,13,69,202,115,18,7,
+  40,0,65,67,134,200,193,151,59,214,227,108,33,151,12,252,68,54,151,15,113,172,239,220,147,61,36,123,55,55,181,25,
+  99,135,1,252,32,117,62,44,230,191,187,253,190,39,215,221,179,122,27,209,200,47,224,44,206,89,112,46,182,234,92,172,
+  151,250,255,100,204,207,220,69,118,228,34,95,125,240,242,69,92,120,38,178,246,9,0,177,108,85,198,68,111,3,160,100,
+  205,149,98,126,69,208,152,121,106,249,170,173,68,163,191,99,139,19,216,98,14,23,94,41,139,13,167,233,197,220,117,199,
+  242,127,158,165,113,206,34,238,94,185,161,69,180,30,182,74,47,22,56,234,20,59,167,252,5,7,182,207,57,252,248,230,
+  221,15,167,51,11,175,153,31,254,11,190,221,191,61,55,116,254,199,141,157,187,42,98,0,96,95,119,211,67,98,237,81,
+  165,117,81,68,121,162,52,206,70,53,152,118,51,206,136,196,182,28,46,111,163,40,0,120,126,79,86,166,16,112,32,31,
+  118,55,183,0,20,109,116,169,99,237,171,12,28,235,169,110,177,70,220,124,255,58,190,255,124,7,158,210,109,0,158,248,
+  197,103,119,13,102,1,76,153,37,56,118,143,94,6,232,221,146,38,145,74,147,76,165,235,66,32,72,54,2,176,161,100,
+  191,18,230,170,213,37,40,109,240,147,13,117,33,160,141,55,227,220,140,4,180,241,240,19,245,241,128,54,126,237,4,140,
+  246,8,18,245,241,128,249,247,30,184,145,4,60,143,160,78,49,96,252,242,21,248,64,225,90,4,2,160,21,226,138,103,
+  252,20,184,90,114,65,21,136,66,169,114,209,189,5,24,3,46,1,81,53,2,205,64,198,41,111,112,184,255,204,220,204,
+  194,142,210,112,69,146,113,149,9,199,149,117,87,117,77,220,14,245,247,97,197,27,2,230,151,246,140,74,36,166,16,208,
+  37,221,251,226,244,196,91,216,157,175,11,97,75,141,231,173,10,135,25,249,228,196,196,59,64,2,240,168,120,135,76,207,
+  249,173,64,166,212,6,196,119,86,15,20,0,5,100,137,79,126,30,40,86,35,0,144,4,90,74,155,207,24,164,53,34,
+  36,190,143,81,96,28,38,31,183,215,171,122,245,170,138,51,87,170,89,220,104,252,13,162,179,143,166,193,167,182,66,0,
+  0,0,0,73,69,78,68,174,66,96,130,
+};
+
+};

ananke/resource/resource.hpp

@@ -0,0 +1,7 @@
+namespace resource {
+  extern const uint8_t home[606];
+  extern const uint8_t up[652];
+  extern const uint8_t folder[1176];
+  extern const uint8_t file[844];
+  extern const uint8_t archive[1067];
+};

ananke/sufami-turbo.cpp

@@ -0,0 +1,90 @@
+void Ananke::copySufamiTurboSaves(const string &pathname) {
+  if(!file::exists({pathname, "save.ram"})) {
+    if(file::exists({information.path, nall::basename(information.name), ".srm"})) {
+      file::copy({information.path, nall::basename(information.name), ".srm"}, {pathname, "save.ram"});
+    }
+  }
+}
+
+string Ananke::createSufamiTurboDatabase(vector<uint8_t> &buffer, Markup::Node &document, const string &manifest) {
+  string pathname = {
+    libraryPath, "Sufami Turbo/",
+    document["release/information/name"].text(),
+    " (", document["release/information/region"].text(), ")",
+    " (", document["release/information/revision"].text(), ")",
+    ".st/"
+  };
+  directory::create(pathname);
+
+  //strip "release" root node from database entry (since a single game manifest isn't part of a database)
+  string markup = manifest;
+  markup.replace("\n  ", "\n");
+  markup.replace("information", "\ninformation");
+  markup.ltrim<1>("release\n");
+
+  file::write({pathname, "manifest.bml"}, markup);
+  file::write({pathname, "program.rom"}, buffer);
+  copySufamiTurboSaves(pathname);
+
+  return pathname;
+}
+
+string Ananke::createSufamiTurboHeuristic(vector<uint8_t> &buffer) {
+  string pathname = {
+    libraryPath, "Sufami Turbo/",
+    nall::basename(information.name),
+    ".st/"
+  };
+  directory::create(pathname);
+
+  file::write({pathname, "manifest.bml"}, {
+    "unverified\n",
+    "\n",
+    "cartridge\n",
+    "  rom name=program.rom size=0x", hex(buffer.size()), "\n",
+    "  ram name=save.ram size=0x2000\n",
+    "\n",
+    "information\n",
+    "  title: ", nall::basename(information.name), "\n"
+  });
+  file::write({pathname, "program.rom"}, buffer);
+  copySufamiTurboSaves(pathname);
+
+  return pathname;
+}
+
+string Ananke::openSufamiTurbo(vector<uint8_t> &buffer) {
+  string sha256 = nall::sha256(buffer.data(), buffer.size());
+
+  string databaseText = string::read({configpath(), "ananke/database/Sufami Turbo.bml"}).strip();
+  if(databaseText.empty()) databaseText = string{Database::SufamiTurbo}.strip();
+  lstring databaseItem = databaseText.split("\n\n");
+
+  for(auto &item : databaseItem) {
+    item.append("\n");
+    auto document = Markup::Document(item);
+
+    if(document["release/information/sha256"].text() == sha256) {
+      return createSufamiTurboDatabase(buffer, document, item);
+    }
+  }
+
+  return createSufamiTurboHeuristic(buffer);
+}
+
+string Ananke::syncSufamiTurbo(const string &pathname) {
+  auto buffer = file::read({pathname, "program.rom"});
+  if(buffer.size() == 0) return "";
+
+  auto save = file::read({pathname, "save.ram"});
+  if(save.size() == 0) save = file::read({pathname, "save.rwm"});
+
+  directory::remove(pathname);
+  information.path = pathname;
+  information.name = notdir(string{pathname}.rtrim<1>("/"));
+  string outputPath = openSufamiTurbo(buffer);
+
+  if(save.size()) file::write({outputPath, "save.ram"}, save);
+
+  return outputPath;
+}

ananke/super-famicom.cpp

@@ -0,0 +1,215 @@
+void Ananke::copySuperFamicomSaves(const string &pathname) {
+  if(!file::exists({pathname, "save.ram"})) {
+    if(file::exists({information.path, nall::basename(information.name), ".srm"})) {
+      file::copy({information.path, nall::basename(information.name), ".srm"}, {pathname, "save.ram"});
+    }
+  }
+
+  if(!file::exists({pathname, "rtc.ram"})) {
+    if(file::exists({information.path, nall::basename(information.name), ".rtc"})) {
+      file::copy({information.path, nall::basename(information.name), ".rtc"}, {pathname, "rtc.ram"});
+    }
+  }
+}
+
+string Ananke::createSuperFamicomDatabase(vector<uint8_t> &buffer, Markup::Node &document, const string &manifest) {
+  string pathname = {
+    libraryPath, "Super Famicom/",
+    document["release/information/name"].text(),
+    " (", document["release/information/region"].text(), ")",
+    " (", document["release/information/revision"].text(), ")",
+    ".sfc/"
+  };
+  directory::create(pathname);
+
+  //strip "release" root node from database entry (since a single game manifest isn't part of a database)
+  string markup = manifest;
+  markup.replace("\n  ", "\n");
+  markup.replace("information", "\ninformation");
+  markup.ltrim<1>("release\n");
+
+  file::write({pathname, "manifest.bml"}, markup);
+
+  unsigned offset = 0;
+  for(auto &node : document["release/information/configuration"]) {
+    if(node.name != "rom") continue;
+    string name = node["name"].text();
+    unsigned size = node["size"].decimal();
+    file::write({pathname, name}, buffer.data() + offset, size);
+    offset += size;
+  }
+
+  copySuperFamicomSaves(pathname);
+  return pathname;
+}
+
+string Ananke::createSuperFamicomHeuristic(vector<uint8_t> &buffer) {
+  string pathname = {
+    libraryPath, "Super Famicom/",
+    nall::basename(information.name),
+    ".sfc/"
+  };
+  directory::create(pathname);
+
+  if((buffer.size() & 0x7fff) == 512) buffer.remove(0, 512);  //strip copier header, if present
+
+  SuperFamicomCartridge info(buffer.data(), buffer.size());
+  string markup = {"unverified\n\n", info.markup};
+  markup.append("\ninformation\n  title: ", nall::basename(information.name), "\n");
+  if(!information.manifest.empty()) markup = information.manifest;  //override with embedded beat manifest, if one exists
+  information.manifest = markup;  //save for use with firmware routine below
+
+  file::write({pathname, "manifest.bml"}, markup);
+
+  if(!markup.find("spc7110")) {
+    file::write({pathname, "program.rom"}, buffer.data(), info.rom_size);
+  } else {
+    file::write({pathname, "program.rom"}, buffer.data(), 0x100000);
+    file::write({pathname, "data.rom"}, buffer.data() + 0x100000, info.rom_size - 0x100000);
+  }
+
+  createSuperFamicomHeuristicFirmware(buffer, pathname, info.firmware_appended);
+  copySuperFamicomSaves(pathname);
+
+  return pathname;
+}
+
+void Ananke::createSuperFamicomHeuristicFirmware(vector<uint8_t> &buffer, const string &pathname, bool firmware_appended) {
+  auto copyFirmwareInternal = [&](const string &name, unsigned programSize, unsigned dataSize, unsigned bootSize) {
+    //firmware appended directly onto .sfc file
+    string basename = nall::basename(name);
+    if(programSize) file::write({pathname, basename, ".program.rom"}, buffer.data() + buffer.size() - programSize - dataSize - bootSize, programSize);
+    if(dataSize) file::write({pathname, basename, ".data.rom"}, buffer.data() + buffer.size() - dataSize - bootSize, dataSize);
+    if(bootSize) file::write({pathname, basename, ".boot.rom"}, buffer.data() + buffer.size() - bootSize, bootSize);
+  };
+
+  auto copyFirmwareExternal = [&](const string &name, unsigned programSize, unsigned dataSize, unsigned bootSize) {
+    //firmware stored in external file
+    auto buffer = file::read({information.path, name});  //try and read from the containing directory
+    if(buffer.size() == 0) buffer = extractFile(name);  //try and read from the containing archive, if one exists
+    if(buffer.size() == 0) {
+      if(thread::primary()) MessageWindow().setText({
+        "Error: ", information.name, "\n\n",
+        "Required firmware ", name, " not found. Game will not be playable!\n\n",
+        "You must obtain this file, and place it in the same folder as this game."
+      }).error();
+      return;
+    }
+
+    string basename = nall::basename(name);
+    if(programSize) file::write({pathname, basename, ".program.rom"}, buffer.data(), programSize);
+    if(dataSize) file::write({pathname, basename, ".data.rom"}, buffer.data() + programSize, dataSize);
+    if(bootSize) file::write({pathname, basename, ".boot.rom"}, buffer.data() + programSize + dataSize, bootSize);
+  };
+
+  auto copyFirmware = [&](const string &name, unsigned programSize, unsigned dataSize, unsigned bootSize = 0) {
+    if(firmware_appended == 1) copyFirmwareInternal(name, programSize, dataSize, bootSize);
+    if(firmware_appended == 0) copyFirmwareExternal(name, programSize, dataSize, bootSize);
+  };
+
+  string markup = information.manifest;
+  if(markup.find("dsp1.program.rom" )) copyFirmware("dsp1.rom",  0x001800, 0x000800);
+  if(markup.find("dsp1b.program.rom")) copyFirmware("dsp1b.rom", 0x001800, 0x000800);
+  if(markup.find("dsp2.program.rom" )) copyFirmware("dsp2.rom",  0x001800, 0x000800);
+  if(markup.find("dsp3.program.rom" )) copyFirmware("dsp3.rom",  0x001800, 0x000800);
+  if(markup.find("dsp4.program.rom" )) copyFirmware("dsp4.rom",  0x001800, 0x000800);
+  if(markup.find("st010.program.rom")) copyFirmware("st010.rom", 0x00c000, 0x001000);
+  if(markup.find("st011.program.rom")) copyFirmware("st011.rom", 0x00c000, 0x001000);
+  if(markup.find("st018.program.rom")) copyFirmware("st018.rom", 0x020000, 0x008000);
+  if(markup.find("cx4.data.rom"     )) copyFirmware("cx4.rom",   0x000000, 0x000c00);
+  if(markup.find("sgb.boot.rom"     )) copyFirmware("sgb.rom",   0x000000, 0x000000, 0x000100);
+}
+
+string Ananke::openSuperFamicom(vector<uint8_t> &buffer) {
+  string sha256 = nall::sha256(buffer.data(), buffer.size());
+
+  string databaseText = string::read({configpath(), "ananke/database/Super Famicom.bml"}).strip();
+  if(databaseText.empty()) databaseText = string{Database::SuperFamicom}.strip();
+  lstring databaseItem = databaseText.split("\n\n");
+
+  for(auto &item : databaseItem) {
+    item.append("\n");
+    auto document = Markup::Document(item);
+
+    if(document["release/information/sha256"].text() == sha256) {
+      return createSuperFamicomDatabase(buffer, document, item);
+    }
+  }
+
+  return createSuperFamicomHeuristic(buffer);
+}
+
+string Ananke::syncSuperFamicom(const string &pathname) {
+  if(file::exists({pathname, "msu1.rom"})) return "";  //cannot update MSU1 games
+
+  vector<uint8_t> buffer;
+
+  auto append = [&](string filename) {
+    filename = {pathname, filename};
+    auto data = file::read(filename);
+    if(data.size() == 0) return;  //file does not exist
+
+    unsigned position = buffer.size();
+    buffer.resize(buffer.size() + data.size());
+    memcpy(buffer.data() + position, data.data(), data.size());
+  };
+
+  append("program.rom");
+  append("data.rom");
+
+  append("dsp1.rom");
+  append("dsp1.program.rom");
+  append("dsp1.data.rom");
+
+  append("dsp1b.rom");
+  append("dsp1b.program.rom");
+  append("dsp1b.data.rom");
+
+  append("dsp2.rom");
+  append("dsp2.program.rom");
+  append("dsp2.data.rom");
+
+  append("dsp3.rom");
+  append("dsp3.program.rom");
+  append("dsp3.data.rom");
+
+  append("dsp4.rom");
+  append("dsp4.program.rom");
+  append("dsp4.data.rom");
+
+  append("st010.rom");
+  append("st010.program.rom");
+  append("st010.data.rom");
+
+  append("st011.rom");
+  append("st011.program.rom");
+  append("st011.data.rom");
+
+  append("st018.rom");
+  append("st018.program.rom");
+  append("st018.data.rom");
+
+  append("cx4.rom");
+  append("cx4.data.rom");
+
+  append("sgb.rom");
+  append("sgb.boot.rom");
+
+  if(buffer.size() == 0) return "";
+
+  auto save = file::read({pathname, "save.ram"});
+  if(save.size() == 0) save = file::read({pathname, "save.rwm"});
+
+  auto rtc = file::read({pathname, "rtc.ram"});
+  if(rtc.size() == 0) rtc= file::read({pathname, "rtc.rwm"});
+
+  directory::remove(pathname);
+  information.path = pathname;
+  information.name = notdir(string{pathname}.rtrim<1>("/"));
+  string outputPath = openSuperFamicom(buffer);
+
+  if(save.size()) file::write({outputPath, "save.ram"}, save);
+  if(rtc.size()) file::write({outputPath, "rtc.ram"}, save);
+
+  return outputPath;
+}

bsnes/Makefile

@@ -1,79 +0,0 @@
-include nall/Makefile
-
-snes := snes
-gameboy := gameboy
-profile := accuracy
-ui := ui
-
-# options += debugger
-
-# compiler
-c       := $(compiler) -std=gnu99
-cpp     := $(subst cc,++,$(compiler)) -std=gnu++0x
-flags   := -O3 -fomit-frame-pointer -I.
-link    :=
-objects := libco
-
-# profile-guided optimization mode
-# pgo := instrument
-# pgo := optimize
-
-ifeq ($(pgo),instrument)
-  flags += -fprofile-generate
-  link += -lgcov
-else ifeq ($(pgo),optimize)
-  flags += -fprofile-use
-endif
-
-flags := $(flags) $(foreach o,$(call strupper,$(options)),-D$o)
-
-# platform
-ifeq ($(platform),x)
-  link += -s -ldl -lX11 -lXext
-else ifeq ($(platform),osx)
-else ifeq ($(platform),win)
-  link += -mwindows
-# link += -mconsole
-  link += -mthreads -s -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32 -lole32
-  link += -enable-stdcall-fixup -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc
-else
-  unknown_platform: help;
-endif
-
-# implicit rules
-compile = \
-  $(strip \
-    $(if $(filter %.c,$<), \
-      $(c) $(flags) $1 -c $< -o $@, \
-      $(if $(filter %.cpp,$<), \
-        $(cpp) $(flags) $1 -c $< -o $@ \
-      ) \
-    ) \
-  )
-
-%.o: $<; $(call compile)
-
-all: build;
-
-obj/libco.o: libco/libco.c libco/*
-
-include $(ui)/Makefile
-
-# targets
-clean:
-	-@$(call delete,obj/*.o)
-	-@$(call delete,obj/*.a)
-	-@$(call delete,obj/*.so)
-	-@$(call delete,obj/*.dylib)
-	-@$(call delete,obj/*.dll)
-	-@$(call delete,*.res)
-	-@$(call delete,*.pgd)
-	-@$(call delete,*.pgc)
-	-@$(call delete,*.ilk)
-	-@$(call delete,*.pdb)
-	-@$(call delete,*.manifest)
-
-archive-all:
-	tar -cjf bsnes.tar.bz2 data gameboy libco nall obj out phoenix ruby snes ui ui-gameboy ui-libsnes Makefile cc.bat clean.bat sync.sh
-
-help:;

bsnes/cc.bat

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

bsnes/clean.bat

@@ -1 +0,0 @@
-@mingw32-make clean

bsnes/gameboy/Makefile

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

bsnes/gameboy/apu/master/master.cpp

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

bsnes/gameboy/apu/square1/square1.hpp

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

bsnes/gameboy/apu/square2/square2.hpp

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

bsnes/gameboy/cartridge/cartridge.cpp

@@ -1,156 +0,0 @@
-#include <gameboy/gameboy.hpp>
-
-#include <nall/crc32.hpp>
-
-#define CARTRIDGE_CPP
-namespace GameBoy {
-
-#include "mbc0/mbc0.cpp"
-#include "mbc1/mbc1.cpp"
-#include "mbc2/mbc2.cpp"
-#include "mbc3/mbc3.cpp"
-#include "mbc5/mbc5.cpp"
-#include "mmm01/mmm01.cpp"
-#include "huc1/huc1.cpp"
-#include "huc3/huc3.cpp"
-#include "serialization.cpp"
-Cartridge cartridge;
-
-void Cartridge::load(const string &xml, const uint8_t *data, unsigned size) {
-  if(size == 0) size = 32768;
-  romdata = allocate<uint8>(romsize = size, 0xff);
-  if(data) memcpy(romdata, data, size);
-
-//uint32_t crc = crc32_calculate(data, size);
-//print("CRC32 = ", hex<4>(crc), "\n");
-
-  info.mapper = Mapper::Unknown;
-  info.ram = false;
-  info.battery = false;
-  info.rtc = false;
-  info.rumble = false;
-
-  info.romsize = 0;
-  info.ramsize = 0;
-
-  xml_element document = xml_parse(xml);
-  foreach(head, document.element) {
-    if(head.name == "cartridge") {
-      foreach(attr, head.attribute) {
-        if(attr.name == "mapper") {
-          if(attr.content == "none")  info.mapper = Mapper::MBC0;
-          if(attr.content == "MBC1")  info.mapper = Mapper::MBC1;
-          if(attr.content == "MBC2")  info.mapper = Mapper::MBC2;
-          if(attr.content == "MBC3")  info.mapper = Mapper::MBC3;
-          if(attr.content == "MBC5")  info.mapper = Mapper::MBC5;
-          if(attr.content == "MMM01") info.mapper = Mapper::MMM01;
-          if(attr.content == "HuC1")  info.mapper = Mapper::HuC1;
-          if(attr.content == "HuC3")  info.mapper = Mapper::HuC3;
-        }
-
-        if(attr.name == "rtc") info.rtc = (attr.content == "true" ? true : false);
-        if(attr.name == "rumble") info.rumble = (attr.content == "true" ? true : false);
-      }
-
-      foreach(elem, head.element) {
-        if(elem.name == "rom") {
-          foreach(attr, elem.attribute) {
-            if(attr.name == "size") info.romsize = hex(attr.content);
-          }
-        }
-
-        if(elem.name == "ram") {
-          info.ram = true;
-          foreach(attr, elem.attribute) {
-            if(attr.name == "size") info.ramsize = hex(attr.content);
-            if(attr.name == "battery") info.battery = (attr.content == "true" ? true : false);
-          }
-        }
-      }
-    }
-  }
-
-  switch(info.mapper) { default:
-    case Mapper::MBC0:  mapper = &mbc0;  break;
-    case Mapper::MBC1:  mapper = &mbc1;  break;
-    case Mapper::MBC2:  mapper = &mbc2;  break;
-    case Mapper::MBC3:  mapper = &mbc3;  break;
-    case Mapper::MBC5:  mapper = &mbc5;  break;
-    case Mapper::MMM01: mapper = &mmm01; break;
-    case Mapper::HuC1:  mapper = &huc1;  break;
-    case Mapper::HuC3:  mapper = &huc3;  break;
-  }
-
-  ramdata = new uint8_t[ramsize = info.ramsize]();
-  system.load();
-  loaded = true;
-}
-
-void Cartridge::unload() {
-  if(loaded == false) return;
-
-  if(romdata) { delete[] romdata; romdata = 0; }
-  if(ramdata) { delete[] ramdata; ramdata = 0; }
-  loaded = false;
-}
-
-uint8 Cartridge::rom_read(unsigned addr) {
-  if(addr >= romsize) addr %= romsize;
-  return romdata[addr];
-}
-
-void Cartridge::rom_write(unsigned addr, uint8 data) {
-  if(addr >= romsize) addr %= romsize;
-  romdata[addr] = data;
-}
-
-uint8 Cartridge::ram_read(unsigned addr) {
-  if(ramsize == 0) return 0x00;
-  if(addr >= ramsize) addr %= ramsize;
-  return ramdata[addr];
-}
-
-void Cartridge::ram_write(unsigned addr, uint8 data) {
-  if(ramsize == 0) return;
-  if(addr >= ramsize) addr %= ramsize;
-  ramdata[addr] = data;
-}
-
-uint8 Cartridge::mmio_read(uint16 addr) {
-  if(bootrom_enable && within<0x0000, 0x00ff>(addr)) return System::BootROM::sgb[addr];
-  return mapper->mmio_read(addr);
-}
-
-void Cartridge::mmio_write(uint16 addr, uint8 data) {
-  if(bootrom_enable && addr == 0xff50) bootrom_enable = false;
-  mapper->mmio_write(addr, data);
-}
-
-void Cartridge::power() {
-  bootrom_enable = true;
-
-  mbc0.power();
-  mbc1.power();
-  mbc2.power();
-  mbc3.power();
-  mbc5.power();
-  mmm01.power();
-  huc1.power();
-  huc3.power();
-
-  for(unsigned n = 0x0000; n <= 0x7fff; n++) bus.mmio[n] = this;
-  for(unsigned n = 0xa000; n <= 0xbfff; n++) bus.mmio[n] = this;
-  bus.mmio[0xff50] = this;
-}
-
-Cartridge::Cartridge() {
-  loaded = false;
-  romdata = 0;
-  ramdata = 0;
-}
-
-Cartridge::~Cartridge() {
-  unload();
-}
-
-}

bsnes/gameboy/cartridge/huc1/huc1.cpp

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

bsnes/gameboy/cartridge/huc1/huc1.hpp

@@ -1,9 +0,0 @@
-struct HuC1 : MMIO {
-  bool ram_enable;   //0000-1fff
-  uint8 rom_select;  //2000-3fff
-  uint8 ram_select;  //4000-5fff
-
-  uint8 mmio_read(uint16 addr);
-  void mmio_write(uint16 addr, uint8 data);
-  void power();
-} huc1;

bsnes/gameboy/cartridge/mbc1/mbc1.hpp

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

bsnes/gameboy/cpu/core/core.hpp

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

bsnes/gameboy/cpu/core/table.cpp

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

bsnes/gameboy/cpu/mmio/mmio.cpp

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

bsnes/gameboy/cpu/mmio/mmio.hpp

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

bsnes/gameboy/cpu/timing/timing.hpp

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

bsnes/gameboy/gameboy.hpp

@@ -1,96 +0,0 @@
-//bgameboy
-//author: byuu
-//project started: 2010-12-27
-
-namespace GameBoy {
-  namespace Info {
-    static const char Name[] = "bgameboy";
-    static const char Version[] = "000.21";
-    static unsigned SerializerVersion = 2;
-  }
-}
-
-#include <libco/libco.h>
-
-#include <nall/foreach.hpp>
-#include <nall/platform.hpp>
-#include <nall/property.hpp>
-#include <nall/random.hpp>
-#include <nall/serializer.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-#include <nall/varint.hpp>
-using namespace nall;
-
-namespace GameBoy {
-  typedef int8_t  int8;
-  typedef int16_t int16;
-  typedef int32_t int32;
-  typedef int64_t int64;
-
-  typedef uint8_t  uint8;
-  typedef uint16_t uint16;
-  typedef uint32_t uint32;
-  typedef uint64_t uint64;
-
-  typedef uint_t< 1> uint1;
-  typedef uint_t< 2> uint2;
-  typedef uint_t< 3> uint3;
-  typedef uint_t< 4> uint4;
-  typedef uint_t< 5> uint5;
-  typedef uint_t< 6> uint6;
-  typedef uint_t< 7> uint7;
-
-  typedef uint_t< 9> uint9;
-  typedef uint_t<10> uint10;
-  typedef uint_t<11> uint11;
-  typedef uint_t<12> uint12;
-  typedef uint_t<13> uint13;
-  typedef uint_t<14> uint14;
-  typedef uint_t<15> uint15;
-
-  typedef uint_t<17> uint17;
-  typedef uint_t<18> uint18;
-  typedef uint_t<19> uint19;
-  typedef uint_t<20> uint20;
-  typedef uint_t<21> uint21;
-  typedef uint_t<22> uint22;
-  typedef uint_t<23> uint23;
-  typedef uint_t<24> uint24;
-  typedef uint_t<25> uint25;
-  typedef uint_t<26> uint26;
-  typedef uint_t<27> uint27;
-  typedef uint_t<28> uint28;
-  typedef uint_t<29> uint29;
-  typedef uint_t<30> uint30;
-  typedef uint_t<31> uint31;
-
-  template<uint16 lo, uint16 hi>
-  alwaysinline bool within(uint16 addr) {
-    static const uint16 mask = ~(hi ^ lo);
-    return (addr & mask) == lo;
-  }
-
-  struct Processor {
-    cothread_t thread;
-    unsigned frequency;
-    int64 clock;
-
-    inline void create(void (*entrypoint_)(), unsigned frequency_) {
-      if(thread) co_delete(thread);
-      thread = co_create(65536 * sizeof(void*), entrypoint_);
-      frequency = frequency_;
-      clock = 0;
-    }
-
-    inline Processor() : thread(0) {}
-  };
-
-  #include <gameboy/memory/memory.hpp>
-  #include <gameboy/system/system.hpp>
-  #include <gameboy/scheduler/scheduler.hpp>
-  #include <gameboy/cartridge/cartridge.hpp>
-  #include <gameboy/cpu/cpu.hpp>
-  #include <gameboy/apu/apu.hpp>
-  #include <gameboy/lcd/lcd.hpp>
-};

bsnes/gameboy/interface/interface.hpp

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

bsnes/gameboy/lcd/lcd.cpp

@@ -1,251 +0,0 @@
-#include <gameboy/gameboy.hpp>
-
-#define LCD_CPP
-namespace GameBoy {
-
-#include "mmio/mmio.cpp"
-#include "serialization.cpp"
-LCD lcd;
-
-void LCD::Main() {
-  lcd.main();
-}
-
-void LCD::main() {
-  while(true) {
-    if(scheduler.sync == Scheduler::SynchronizeMode::All) {
-      scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
-    }
-
-    add_clocks(4);
-    status.lx += 4;
-    if(status.lx >= 456) scanline();
-
-    if(status.display_enable && status.lx == 0) {
-      if(status.interrupt_oam) cpu.interrupt_raise(CPU::Interrupt::Stat);
-    }
-
-    if(status.display_enable && status.lx == 252) {
-      if(status.interrupt_hblank) cpu.interrupt_raise(CPU::Interrupt::Stat);
-    }
-  }
-}
-
-void LCD::add_clocks(unsigned clocks) {
-  clock += clocks;
-  if(clock >= 0 && scheduler.sync != Scheduler::SynchronizeMode::All) {
-    co_switch(scheduler.active_thread = cpu.thread);
-  }
-}
-
-void LCD::scanline() {
-  status.lx -= 456;
-  if(++status.ly == 154) frame();
-
-  if(status.display_enable && status.interrupt_lyc == true) {
-    if(status.ly == status.lyc) cpu.interrupt_raise(CPU::Interrupt::Stat);
-  }
-
-  if(status.ly < 144) render();
-
-  if(status.display_enable && status.ly == 144) {
-    cpu.interrupt_raise(CPU::Interrupt::Vblank);
-    if(status.interrupt_vblank) cpu.interrupt_raise(CPU::Interrupt::Stat);
-  }
-}
-
-void LCD::frame() {
-  system.interface->video_refresh(screen);
-  system.interface->input_poll();
-  cpu.mmio_joyp_poll();
-
-  status.ly = 0;
-  scheduler.exit(Scheduler::ExitReason::FrameEvent);
-}
-
-void LCD::render() {
-  for(unsigned n = 0; n < 160; n++) {
-    line[n] = 0x00;
-    origin[n] = Origin::None;
-  }
-
-  if(status.display_enable == true) {
-    if(status.bg_enable == true) render_bg();
-    if(status.window_display_enable == true) render_window();
-    if(status.obj_enable == true) render_obj();
-  }
-
-  uint8_t *output = screen + status.ly * 160;
-  for(unsigned n = 0; n < 160; n++) output[n] = (3 - line[n]) * 0x55;
-  system.interface->lcd_scanline();
-}
-
-uint16 LCD::read_tile(bool select, unsigned x, unsigned y) {
-  unsigned tmaddr = 0x1800 + (select << 10), tdaddr;
-  tmaddr += (((y >> 3) << 5) + (x >> 3)) & 0x03ff;
-  if(status.bg_tiledata_select == 0) {
-    tdaddr = 0x1000 + ((int8)vram[tmaddr] << 4);
-  } else {
-    tdaddr = 0x0000 + (vram[tmaddr] << 4);
-  }
-  tdaddr += (y & 7) << 1;
-  return (vram[tdaddr + 0] << 0) | (vram[tdaddr + 1] << 8);
-}
-
-void LCD::render_bg() {
-  unsigned iy = (status.ly + status.scy) & 255;
-  unsigned ix = status.scx, tx = ix & 7;
-  unsigned data = read_tile(status.bg_tilemap_select, ix, iy);
-
-  for(unsigned ox = 0; ox < 160; ox++) {
-    uint8 palette = ((data & (0x0080 >> tx)) ? 1 : 0)
-                  | ((data & (0x8000 >> tx)) ? 2 : 0);
-
-    line[ox] = status.bgp[palette];
-    origin[ox] = Origin::BG;
-
-    ix = (ix + 1) & 255;
-    tx = (tx + 1) & 7;
-
-    if(tx == 0) data = read_tile(status.bg_tilemap_select, ix, iy);
-  }
-}
-
-void LCD::render_window() {
-  if(status.ly - status.wy >= 144U) return;
-  unsigned iy = status.ly - status.wy;
-  unsigned ix = (7 - status.wx) & 255, tx = ix & 7;
-  unsigned data = read_tile(status.window_tilemap_select, ix, iy);
-
-  for(unsigned ox = 0; ox < 160; ox++) {
-    uint8 palette = ((data & (0x0080 >> tx)) ? 1 : 0)
-                  | ((data & (0x8000 >> tx)) ? 2 : 0);
-    if(ox - (status.wx - 7) < 160U) {
-      line[ox] = status.bgp[palette];
-      origin[ox] = Origin::Window;
-    }
-
-    ix = (ix + 1) & 255;
-    tx = (tx + 1) & 7;
-
-    if(tx == 0) data = read_tile(status.window_tilemap_select, ix, iy);
-  }
-}
-
-void LCD::render_obj() {
-  enum : unsigned { Priority = 0x80, YFlip = 0x40, XFlip = 0x20, Palette = 0x10 };
-
-  unsigned obj_size = (status.obj_size == 0 ? 8 : 16);
-
-  unsigned sprite[10], sprites = 0;
-
-  //find first ten sprites on this scanline
-  for(unsigned s = 0; s < 40; s++) {
-    unsigned sy = oam[(s << 2) + 0] - 16;
-    unsigned sx = oam[(s << 2) + 1] -  8;
-
-    sy = status.ly - sy;
-    if(sy >= obj_size) continue;
-
-    sprite[sprites++] = s;
-    if(sprites == 10) break;
-  }
-
-  //sort by X-coordinate, when equal, lower address comes first
-  for(unsigned x = 0; x < sprites; x++) {
-    for(unsigned y = x + 1; y < sprites; y++) {
-      signed sx = oam[(sprite[x] << 2) + 1] - 8;
-      signed sy = oam[(sprite[y] << 2) + 1] - 8;
-      if(sy < sx) {
-        sprite[x] ^= sprite[y];
-        sprite[y] ^= sprite[x];
-        sprite[x] ^= sprite[y];
-      }
-    }
-  }
-
-  //render backwards, so that first sprite has highest priority
-  for(signed s = sprites - 1; s >= 0; s--) {
-    unsigned n = sprite[s] << 2;
-    unsigned sy = oam[n + 0] - 16;
-    unsigned sx = oam[n + 1] -  8;
-    unsigned tile = oam[n + 2];
-    unsigned attribute = oam[n + 3];
-
-    sy = status.ly - sy;
-    if(sy >= obj_size) continue;
-    if(attribute & YFlip) sy ^= (obj_size - 1);
-
-    unsigned tdaddr = (tile << 4) + (sy << 1);
-    uint8 d0 = vram[tdaddr + 0];
-    uint8 d1 = vram[tdaddr + 1];
-    unsigned xflip = attribute & XFlip ? 7 : 0;
-
-    for(unsigned tx = 0; tx < 8; tx++) {
-      uint8 palette = ((d0 & (0x80 >> tx)) ? 1 : 0)
-                    | ((d1 & (0x80 >> tx)) ? 2 : 0);
-      if(palette == 0) continue;
-
-      palette = status.obp[(bool)(attribute & Palette)][palette];
-      unsigned ox = sx + (tx ^ xflip);
-
-      if(ox <= 159) {
-        if(attribute & Priority) {
-          if(origin[ox] == Origin::BG || origin[ox] == Origin::Window) {
-            if(line[ox] > 0) continue;
-          }
-        }
-        line[ox] = palette;
-        origin[ox] = Origin::OBJ;
-      }
-    }
-  }
-}
-
-void LCD::power() {
-  create(Main, 4194304);
-
-  for(unsigned n = 0x8000; n <= 0x9fff; n++) bus.mmio[n] = this;  //VRAM
-  for(unsigned n = 0xff40; n <= 0xff4b; n++) bus.mmio[n] = this;  //MMIO
-  for(unsigned n = 0xfe00; n <= 0xfe9f; n++) bus.mmio[n] = this;  //OAM
-
-  for(unsigned n = 0; n < 8192; n++) vram[n] = 0x00;
-  for(unsigned n = 0; n <  160; n++) oam [n] = 0x00;
-
-  for(unsigned n = 0; n < 160 * 144; n++) screen[n] = 0x00;
-
-  status.lx = 0;
-
-  status.display_enable = 0;
-  status.window_tilemap_select = 0;
-  status.window_display_enable = 0;
-  status.bg_tiledata_select = 0;
-  status.bg_tilemap_select = 0;
-  status.obj_size = 0;
-  status.obj_enable = 0;
-  status.bg_enable = 0;
-
-  status.interrupt_lyc = 0;
-  status.interrupt_oam = 0;
-  status.interrupt_vblank = 0;
-  status.interrupt_hblank = 0;
-
-  status.scy = 0;
-  status.scx = 0;
-  status.ly = 0;
-  status.lyc = 0;
-
-  for(unsigned n = 0; n < 4; n++) {
-    status.bgp[n] = n;
-    status.obp[0][n] = n;
-    status.obp[1][n] = n;
-  }
-
-  status.wy = 0;
-  status.wx = 0;
-}
-
-LCD::LCD() {
-}
-
-}

bsnes/gameboy/lcd/lcd.hpp

@@ -1,74 +0,0 @@
-struct LCD : Processor, MMIO {
-  #include "mmio/mmio.hpp"
-
-  struct Status {
-    unsigned lx;
-
-    //$ff40  LCDC
-    bool display_enable;
-    bool window_tilemap_select;
-    bool window_display_enable;
-    bool bg_tiledata_select;
-    bool bg_tilemap_select;
-    bool obj_size;
-    bool obj_enable;
-    bool bg_enable;
-
-    //$ff41  STAT
-    bool interrupt_lyc;
-    bool interrupt_oam;
-    bool interrupt_vblank;
-    bool interrupt_hblank;
-
-    //$ff42  SCY
-    uint8 scy;
-
-    //$ff43  SCX
-    uint8 scx;
-
-    //$ff44  LY
-    uint8 ly;
-
-    //$ff45  LYC
-    uint8 lyc;
-
-    //$ff47  BGP
-    uint8 bgp[4];
-
-    //$ff48  OBP0
-    //$ff49  OBP1
-    uint8 obp[2][4];
-
-    //$ff4a  WY
-    uint8 wy;
-
-    //$ff4b  WX
-    uint8 wx;
-  } status;
-
-  uint8 screen[160 * 144];
-  uint8 vram[8192];
-  uint8 oam[160];
-  uint8 line[160];
-
-  struct Origin { enum : unsigned { None, BG, Window, OBJ }; };
-  uint8 origin[160];
-
-  static void Main();
-  void main();
-  void add_clocks(unsigned clocks);
-  void scanline();
-  void frame();
-  void render();
-  uint16 read_tile(bool select, unsigned x, unsigned y);
-  void render_bg();
-  void render_window();
-  void render_obj();
-
-  void power();
-
-  void serialize(serializer&);
-  LCD();
-};
-
-extern LCD lcd;

bsnes/gameboy/lcd/mmio/mmio.hpp

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

bsnes/gameboy/system/bootrom-dmg.cpp

@@ -1,23 +0,0 @@
-#ifdef SYSTEM_CPP
-
-//MD5SUM = 32fbbd84168d3482956eb3c5051637f5
-const uint8_t System::BootROM::dmg[256] = {
-  0x31,0xfe,0xff,0xaf,0x21,0xff,0x9f,0x32,0xcb,0x7c,0x20,0xfb,0x21,0x26,0xff,0x0e,
-  0x11,0x3e,0x80,0x32,0xe2,0x0c,0x3e,0xf3,0xe2,0x32,0x3e,0x77,0x77,0x3e,0xfc,0xe0,
-  0x47,0x11,0x04,0x01,0x21,0x10,0x80,0x1a,0xcd,0x95,0x00,0xcd,0x96,0x00,0x13,0x7b,
-  0xfe,0x34,0x20,0xf3,0x11,0xd8,0x00,0x06,0x08,0x1a,0x13,0x22,0x23,0x05,0x20,0xf9,
-  0x3e,0x19,0xea,0x10,0x99,0x21,0x2f,0x99,0x0e,0x0c,0x3d,0x28,0x08,0x32,0x0d,0x20,
-  0xf9,0x2e,0x0f,0x18,0xf3,0x67,0x3e,0x64,0x57,0xe0,0x42,0x3e,0x91,0xe0,0x40,0x04,
-  0x1e,0x02,0x0e,0x0c,0xf0,0x44,0xfe,0x90,0x20,0xfa,0x0d,0x20,0xf7,0x1d,0x20,0xf2,
-  0x0e,0x13,0x24,0x7c,0x1e,0x83,0xfe,0x62,0x28,0x06,0x1e,0xc1,0xfe,0x64,0x20,0x06,
-  0x7b,0xe2,0x0c,0x3e,0x87,0xe2,0xf0,0x42,0x90,0xe0,0x42,0x15,0x20,0xd2,0x05,0x20,
-  0x4f,0x16,0x20,0x18,0xcb,0x4f,0x06,0x04,0xc5,0xcb,0x11,0x17,0xc1,0xcb,0x11,0x17,
-  0x05,0x20,0xf5,0x22,0x23,0x22,0x23,0xc9,0xce,0xed,0x66,0x66,0xcc,0x0d,0x00,0x0b,
-  0x03,0x73,0x00,0x83,0x00,0x0c,0x00,0x0d,0x00,0x08,0x11,0x1f,0x88,0x89,0x00,0x0e,
-  0xdc,0xcc,0x6e,0xe6,0xdd,0xdd,0xd9,0x99,0xbb,0xbb,0x67,0x63,0x6e,0x0e,0xec,0xcc,
-  0xdd,0xdc,0x99,0x9f,0xbb,0xb9,0x33,0x3e,0x3c,0x42,0xb9,0xa5,0xb9,0xa5,0x42,0x3c,
-  0x21,0x04,0x01,0x11,0xa8,0x00,0x1a,0x13,0xbe,0x20,0xfe,0x23,0x7d,0xfe,0x34,0x20,
-  0xf5,0x06,0x19,0x78,0x86,0x23,0x05,0x20,0xfb,0x86,0x20,0xfe,0x3e,0x01,0xe0,0x50,
-};
-
-#endif

bsnes/gameboy/system/bootrom-sgb.cpp

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

bsnes/gameboy/system/system.cpp

@@ -1,55 +0,0 @@
-#include <gameboy/gameboy.hpp>
-
-#define SYSTEM_CPP
-namespace GameBoy {
-
-#include "bootrom-dmg.cpp"
-#include "bootrom-sgb.cpp"
-#include "serialization.cpp"
-System system;
-
-void System::run() {
-  scheduler.sync = Scheduler::SynchronizeMode::None;
-
-  scheduler.enter();
-  if(scheduler.exit_reason() == Scheduler::ExitReason::FrameEvent) {
-  }
-}
-
-void System::runtosave() {
-  scheduler.sync = Scheduler::SynchronizeMode::CPU;
-  runthreadtosave();
-
-  scheduler.active_thread = lcd.thread;
-  runthreadtosave();
-}
-
-void System::runthreadtosave() {
-  while(true) {
-    scheduler.enter();
-    if(scheduler.exit_reason() == Scheduler::ExitReason::SynchronizeEvent) break;
-    if(scheduler.exit_reason() == Scheduler::ExitReason::FrameEvent) {
-    }
-  }
-}
-
-void System::init(Interface *interface_) {
-  interface = interface_;
-}
-
-void System::load() {
-  serialize_init();
-}
-
-void System::power() {
-  bus.power();
-  cartridge.power();
-  cpu.power();
-  apu.power();
-  lcd.power();
-  scheduler.init();
-
-  clocks_executed = 0;
-}
-
-}

bsnes/nall/Makefile

@@ -1,109 +0,0 @@
-# Makefile
-# author: byuu
-# license: public domain
-
-[A-Z] = A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
-[a-z] = a b c d e f g h i j k l m n o p q r s t u v w x y z
-[0-9] = 0 1 2 3 4 5 6 7 8 9
-[markup] = ` ~ ! @ \# $$ % ^ & * ( ) - _ = + [ { ] } \ | ; : ' " , < . > / ?
-[all] = $([A-Z]) $([a-z]) $([0-9]) $([markup])
-[space] :=
-[space] +=
-
-#####
-# platform detection
-#####
-
-ifeq ($(platform),)
-  uname := $(shell uname -a)
-  ifeq ($(uname),)
-    platform := win
-    delete = del $(subst /,\,$1)
-  else ifneq ($(findstring Darwin,$(uname)),)
-    platform := osx
-    delete = rm -f $1
-  else
-    platform := x
-    delete = rm -f $1
-  endif
-endif
-
-ifeq ($(compiler),)
-  ifeq ($(platform),win)
-    compiler := gcc
-  else ifeq ($(platform),osx)
-    compiler := gcc-mp-4.5
-  else
-    compiler := gcc-4.5
-  endif
-endif
-
-ifeq ($(prefix),)
-  prefix := /usr/local
-endif
-
-#####
-# function rwildcard(directory, pattern)
-#####
-rwildcard = \
-  $(strip \
-    $(filter $(if $2,$2,%), \
-      $(foreach f, \
-        $(wildcard $1*), \
-        $(eval t = $(call rwildcard,$f/)) \
-        $(if $t,$t,$f) \
-      ) \
-    ) \
-  )
-
-#####
-# function strtr(source, from, to)
-#####
-strtr = \
-  $(eval __temp := $1) \
-  $(strip \
-    $(foreach c, \
-      $(join $(addsuffix :,$2),$3), \
-      $(eval __temp := \
-        $(subst $(word 1,$(subst :, ,$c)),$(word 2,$(subst :, ,$c)),$(__temp)) \
-      ) \
-    ) \
-    $(__temp) \
-  )
-
-#####
-# function strupper(source)
-#####
-strupper = $(call strtr,$1,$([a-z]),$([A-Z]))
-
-#####
-# function strlower(source)
-#####
-strlower = $(call strtr,$1,$([A-Z]),$([a-z]))
-
-#####
-# function strlen(source)
-#####
-strlen = \
-  $(eval __temp := $(subst $([space]),_,$1)) \
-  $(words \
-    $(strip \
-      $(foreach c, \
-        $([all]), \
-        $(eval __temp := \
-          $(subst $c,$c ,$(__temp)) \
-        ) \
-      ) \
-      $(__temp) \
-    ) \
-  )
-
-#####
-# function streq(source)
-#####
-streq = $(if $(filter-out xx,x$(subst $1,,$2)$(subst $2,,$1)x),,1)
-
-#####
-# function strne(source)
-#####
-strne = $(if $(filter-out xx,x$(subst $1,,$2)$(subst $2,,$1)x),1,)

bsnes/nall/algorithm.hpp

@@ -1,17 +0,0 @@
-#ifndef NALL_ALGORITHM_HPP
-#define NALL_ALGORITHM_HPP
-
-#undef min
-#undef max
-
-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;
-  }
-}
-
-#endif

bsnes/nall/any.hpp

@@ -1,74 +0,0 @@
-#ifndef NALL_ANY_HPP
-#define NALL_ANY_HPP
-
-#include <typeinfo>
-#include <type_traits>
-#include <nall/static.hpp>
-
-namespace nall {
-  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<
-        std::is_array<T>::value,
-        typename std::remove_extent<typename std::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_);
-      }
-
-      return *this;
-    }
-
-    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;
-
-    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> T any_cast(any &value) {
-    typedef typename std::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 std::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;
-  }
-}
-
-#endif

bsnes/nall/array.hpp

@@ -1,151 +0,0 @@
-#ifndef NALL_ARRAY_HPP
-#define NALL_ARRAY_HPP
-
-#include <stdlib.h>
-#include <initializer_list>
-#include <type_traits>
-#include <utility>
-#include <nall/algorithm.hpp>
-#include <nall/bit.hpp>
-#include <nall/concept.hpp>
-#include <nall/foreach.hpp>
-#include <nall/utility.hpp>
-
-namespace nall {
-  //dynamic vector array
-  //neither constructor nor destructor is ever invoked;
-  //thus, this should only be used for POD objects.
-  template<typename T> class array {
-  protected:
-    T *pool;
-    unsigned poolsize, buffersize;
-
-  public:
-    unsigned size() const { return buffersize; }
-    unsigned capacity() const { return poolsize; }
-
-    void reset() {
-      if(pool) free(pool);
-      pool = 0;
-      poolsize = 0;
-      buffersize = 0;
-    }
-
-    void reserve(unsigned newsize) {
-      if(newsize == poolsize) return;
-
-      pool = (T*)realloc(pool, newsize * sizeof(T));
-      poolsize = newsize;
-      buffersize = min(buffersize, newsize);
-    }
-
-    void resize(unsigned newsize) {
-      if(newsize > poolsize) reserve(bit::round(newsize));  //round reserve size up to power of 2
-      buffersize = newsize;
-    }
-
-    T* get(unsigned minsize = 0) {
-      if(minsize > buffersize) resize(minsize);
-      if(minsize > buffersize) throw "array[] out of bounds";
-      return pool;
-    }
-
-    void append(const T data) {
-      operator[](buffersize) = data;
-    }
-
-    void remove() {
-      if(size > 0) resize(size - 1);  //remove last element only
-    }
-
-    template<typename U> void insert(unsigned index, const U list) {
-      unsigned listsize = container_size(list);
-      resize(buffersize + listsize);
-      memmove(pool + index + listsize, pool + index, (buffersize - index) * sizeof(T));
-      foreach(item, list) pool[index++] = item;
-    }
-
-    void insert(unsigned index, const T item) {
-      insert(index, array<T>{ item });
-    }
-
-    void remove(unsigned index, unsigned count = 1) {
-      for(unsigned i = index; count + i < buffersize; i++) {
-        pool[i] = pool[count + i];
-      }
-      if(count + index >= buffersize) resize(index);  //every element >= index was removed
-      else resize(buffersize - count);
-    }
-
-    optional<unsigned> find(const T data) {
-      for(unsigned i = 0; i < size(); i++) if(pool[i] == data) return { true, i };
-      return { false, 0 };
-    }
-
-    void clear() {
-      memset(pool, 0, buffersize * sizeof(T));
-    }
-
-    array() : pool(0), poolsize(0), buffersize(0) {
-    }
-
-    array(std::initializer_list<T> list) : pool(0), poolsize(0), buffersize(0) {
-      for(const T *p = list.begin(); p != list.end(); ++p) append(*p);
-    }
-
-    ~array() {
-      reset();
-    }
-
-    //copy
-    array& operator=(const array &source) {
-      if(pool) free(pool);
-      buffersize = source.buffersize;
-      poolsize = source.poolsize;
-      pool = (T*)malloc(sizeof(T) * poolsize);            //allocate entire pool size,
-      memcpy(pool, source.pool, sizeof(T) * buffersize);  //... but only copy used pool objects
-      return *this;
-    }
-
-    array(const array &source) : pool(0), poolsize(0), buffersize(0) {
-      operator=(source);
-    }
-
-    //move
-    array& operator=(array &&source) {
-      if(pool) free(pool);
-      pool = source.pool;
-      poolsize = source.poolsize;
-      buffersize = source.buffersize;
-      source.pool = 0;
-      source.reset();
-      return *this;
-    }
-
-    array(array &&source) : pool(0), poolsize(0), buffersize(0) {
-      operator=(std::move(source));
-    }
-
-    //index
-    inline T& operator[](unsigned index) {
-      if(index >= buffersize) resize(index + 1);
-      if(index >= buffersize) throw "array[] out of bounds";
-      return pool[index];
-    }
-
-    inline const T& operator[](unsigned index) const {
-      if(index >= buffersize) throw "array[] out of bounds";
-      return pool[index];
-    }
-
-    //iteration
-    T* begin() { return &pool[0]; }
-    T* end() { return &pool[buffersize]; }
-    const T* begin() const { return &pool[0]; }
-    const T* end() const { return &pool[buffersize]; }
-  };
-
-  template<typename T> struct has_size<array<T>> { enum { value = true }; };
-}
-
-#endif

bsnes/nall/base64.hpp

@@ -1,91 +0,0 @@
-#ifndef NALL_BASE64_HPP
-#define NALL_BASE64_HPP
-
-#include <string.h>
-#include <nall/stdint.hpp>
-
-namespace nall {
-  class base64 {
-  public:
-    static bool encode(char *&output, const uint8_t* input, unsigned inlength) {
-      output = new 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;
-
-          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;
-        }
-
-        i++;
-      }
-
-      return true;
-    }
-
-    static bool decode(uint8_t *&output, unsigned &outlength, const char *input) {
-      unsigned inlength = strlen(input), infix = 0;
-      output = new uint8_t[inlength]();
-
-      unsigned i = 0, o = 0;
-      while(i < inlength) {
-        uint8_t x = dec(input[i]);
-
-        switch(i++ & 3) {
-          case 0: {
-            output[o] = x << 2;
-          } 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 3: {
-            output[o++] |= x;
-          } break;
-        }
-      }
-
-      outlength = o;
-      return true;
-    }
-
-  private:
-    static char enc(uint8_t n) {
-      //base64 for URL encodings
-      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;
-    }
-  };
-}
-
-#endif

bsnes/nall/bit.hpp

@@ -1,51 +0,0 @@
-#ifndef NALL_BIT_HPP
-#define NALL_BIT_HPP
-
-namespace nall {
-  template<int bits> inline unsigned uclamp(const unsigned x) {
-    enum { y = (1U << (bits - 1)) + ((1U << (bits - 1)) - 1) };
-    return y + ((x - y) & -(x < y));  //min(x, y);
-  }
-
-  template<int bits> inline unsigned uclip(const unsigned x) {
-    enum { m = (1U << (bits - 1)) + ((1U << (bits - 1)) - 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;
-    }
-  }
-}
-
-#endif

bsnes/nall/bps/delta.hpp

@@ -1,214 +0,0 @@
-#ifndef NALL_BPS_DELTA_HPP
-#define NALL_BPS_DELTA_HPP
-
-#include <nall/crc32.hpp>
-#include <nall/file.hpp>
-#include <nall/filemap.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-
-namespace nall {
-
-struct bpsdelta {
-  inline void source(const uint8_t *data, unsigned size);
-  inline void target(const uint8_t *data, unsigned size);
-
-  inline bool source(const string &filename);
-  inline bool target(const string &filename);
-  inline bool create(const string &filename, const string &metadata = "");
-
-protected:
-  enum : unsigned { SourceRead, TargetRead, SourceCopy, TargetCopy };
-  enum : unsigned { Granularity = 1 };
-
-  struct Node {
-    unsigned offset;
-    Node *next;
-    inline Node() : offset(0), next(0) {}
-    inline ~Node() { if(next) delete next; }
-  };
-
-  filemap sourceFile;
-  const uint8_t *sourceData;
-  unsigned sourceSize;
-
-  filemap targetFile;
-  const uint8_t *targetData;
-  unsigned targetSize;
-};
-
-void bpsdelta::source(const uint8_t *data, unsigned size) {
-  sourceData = data;
-  sourceSize = size;
-}
-
-void bpsdelta::target(const uint8_t *data, unsigned size) {
-  targetData = data;
-  targetSize = size;
-}
-
-bool bpsdelta::source(const string &filename) {
-  if(sourceFile.open(filename, filemap::mode::read) == false) return false;
-  source(sourceFile.data(), sourceFile.size());
-  return true;
-}
-
-bool bpsdelta::target(const string &filename) {
-  if(targetFile.open(filename, filemap::mode::read) == false) return false;
-  target(targetFile.data(), targetFile.size());
-  return true;
-}
-
-bool bpsdelta::create(const string &filename, const string &metadata) {
-  file modifyFile;
-  if(modifyFile.open(filename, file::mode::write) == false) return false;
-
-  uint32_t sourceChecksum = ~0, modifyChecksum = ~0;
-  unsigned sourceRelativeOffset = 0, targetRelativeOffset = 0, outputOffset = 0;
-
-  auto write = [&](uint8_t data) {
-    modifyFile.write(data);
-    modifyChecksum = crc32_adjust(modifyChecksum, data);
-  };
-
-  auto encode = [&](uint64_t data) {
-    while(true) {
-      uint64_t x = data & 0x7f;
-      data >>= 7;
-      if(data == 0) {
-        write(0x80 | x);
-        break;
-      }
-      write(x);
-      data--;
-    }
-  };
-
-  write('B');
-  write('P');
-  write('S');
-  write('1');
-
-  encode(sourceSize);
-  encode(targetSize);
-
-  unsigned markupSize = metadata.length();
-  encode(markupSize);
-  for(unsigned n = 0; n < markupSize; n++) write(metadata[n]);
-
-  Node *sourceTree[65536], *targetTree[65536];
-  for(unsigned n = 0; n < 65536; n++) sourceTree[n] = 0, targetTree[n] = 0;
-
-  //source tree creation
-  for(unsigned offset = 0; offset < sourceSize; offset++) {
-    uint16_t symbol = sourceData[offset + 0];
-    sourceChecksum = crc32_adjust(sourceChecksum, symbol);
-    if(offset < sourceSize - 1) symbol |= sourceData[offset + 1] << 8;
-    Node *node = new Node;
-    node->offset = offset;
-    node->next = sourceTree[symbol];
-    sourceTree[symbol] = node;
-  }
-
-  unsigned targetReadLength = 0;
-
-  auto targetReadFlush = [&]() {
-    if(targetReadLength) {
-      encode(TargetRead | ((targetReadLength - 1) << 2));
-      unsigned offset = outputOffset - targetReadLength;
-      while(targetReadLength) write(targetData[offset++]), targetReadLength--;
-    }
-  };
-
-  while(outputOffset < targetSize) {
-    unsigned maxLength = 0, maxOffset = 0, mode = TargetRead;
-
-    uint16_t symbol = targetData[outputOffset + 0];
-    if(outputOffset < targetSize - 1) symbol |= targetData[outputOffset + 1] << 8;
-
-    { //source read
-      unsigned length = 0, offset = outputOffset;
-      while(offset < sourceSize && offset < targetSize && sourceData[offset] == targetData[offset]) {
-        length++;
-        offset++;
-      }
-      if(length > maxLength) maxLength = length, mode = SourceRead;
-    }
-
-    { //source copy
-      Node *node = sourceTree[symbol];
-      while(node) {
-        unsigned length = 0, x = node->offset, y = outputOffset;
-        while(x < sourceSize && y < targetSize && sourceData[x++] == targetData[y++]) length++;
-        if(length > maxLength) maxLength = length, maxOffset = node->offset, mode = SourceCopy;
-        node = node->next;
-      }
-    }
-
-    { //target copy
-      Node *node = targetTree[symbol];
-      while(node) {
-        unsigned length = 0, x = node->offset, y = outputOffset;
-        while(y < targetSize && targetData[x++] == targetData[y++]) length++;
-        if(length > maxLength) maxLength = length, maxOffset = node->offset, mode = TargetCopy;
-        node = node->next;
-      }
-
-      //target tree append
-      node = new Node;
-      node->offset = outputOffset;
-      node->next = targetTree[symbol];
-      targetTree[symbol] = node;
-    }
-
-    { //target read
-      if(maxLength < 4) {
-        maxLength = min((unsigned)Granularity, targetSize - outputOffset);
-        mode = TargetRead;
-      }
-    }
-
-    if(mode != TargetRead) targetReadFlush();
-
-    switch(mode) {
-    case SourceRead:
-      encode(SourceRead | ((maxLength - 1) << 2));
-      break;
-    case TargetRead:
-      //delay write to group sequential TargetRead commands into one
-      targetReadLength += maxLength;
-      break;
-    case SourceCopy:
-    case TargetCopy:
-      encode(mode | ((maxLength - 1) << 2));
-      signed relativeOffset;
-      if(mode == SourceCopy) {
-        relativeOffset = maxOffset - sourceRelativeOffset;
-        sourceRelativeOffset = maxOffset + maxLength;
-      } else {
-        relativeOffset = maxOffset - targetRelativeOffset;
-        targetRelativeOffset = maxOffset + maxLength;
-      }
-      encode((relativeOffset < 0) | (abs(relativeOffset) << 1));
-      break;
-    }
-
-    outputOffset += maxLength;
-  }
-
-  targetReadFlush();
-
-  sourceChecksum = ~sourceChecksum;
-  for(unsigned n = 0; n < 32; n += 8) write(sourceChecksum >> n);
-  uint32_t targetChecksum = crc32_calculate(targetData, targetSize);
-  for(unsigned n = 0; n < 32; n += 8) write(targetChecksum >> n);
-  uint32_t outputChecksum = ~modifyChecksum;
-  for(unsigned n = 0; n < 32; n += 8) write(outputChecksum >> n);
-
-  modifyFile.close();
-  return true;
-}
-
-}
-
-#endif

bsnes/nall/compositor.hpp

@@ -1,79 +0,0 @@
-#ifndef NALL_COMPOSITOR_HPP
-#define NALL_COMPOSITOR_HPP
-
-#include <nall/detect.hpp>
-
-namespace nall {
-
-struct compositor {
-  inline static bool enabled();
-  inline static bool enable(bool status);
-};
-
-#if defined(PLATFORM_X)
-
-bool compositor::enabled() {
-  FILE *fp = popen("xfconf-query -c xfwm4 -p '/general/use_compositing'", "r");
-  if(fp == 0) return false;
-
-  char buffer[512];
-  if(fgets(buffer, sizeof buffer, fp) == 0) return false;
-
-  if(!memcmp(buffer, "true", 4)) return true;
-  return false;
-}
-
-bool compositor::enable(bool status) {
-  FILE *fp;
-  if(status) {
-    fp = popen("xfconf-query -c xfwm4 -p '/general/use_compositing' -t 'bool' -s 'true'", "r");
-  } else {
-    fp = popen("xfconf-query -c xfwm4 -p '/general/use_compositing' -t 'bool' -s 'false'", "r");
-  }
-  if(fp == 0) return false;
-  pclose(fp);
-  return true;
-}
-
-#elif defined(PLATFORM_WIN)
-
-bool compositor::enabled() {
-  HMODULE module = GetModuleHandleW(L"dwmapi");
-  if(module == 0) module = LoadLibraryW(L"dwmapi");
-  if(module == 0) return false;
-
-  auto pDwmIsCompositionEnabled = (HRESULT (WINAPI*)(BOOL*))GetProcAddress(module, "DwmIsCompositionEnabled");
-  if(pDwmIsCompositionEnabled == 0) return false;
-
-  BOOL result;
-  if(pDwmIsCompositionEnabled(&result) != S_OK) return false;
-  return result;
-}
-
-bool compositor::enable(bool status) {
-  HMODULE module = GetModuleHandleW(L"dwmapi");
-  if(module == 0) module = LoadLibraryW(L"dwmapi");
-  if(module == 0) return false;
-
-  auto pDwmEnableComposition = (HRESULT (WINAPI*)(UINT))GetProcAddress(module, "DwmEnableComposition");
-  if(pDwmEnableComposition == 0) return false;
-
-  if(pDwmEnableComposition(status) != S_OK) return false;
-  return true;
-}
-
-#else
-
-bool compositor::enabled() {
-  return false;
-}
-
-bool compositor::enable(bool) {
-  return false;
-}
-
-#endif
-
-}
-
-#endif

bsnes/nall/concept.hpp

@@ -1,34 +0,0 @@
-#ifndef NALL_CONCEPT_HPP
-#define NALL_CONCEPT_HPP
-
-#include <nall/static.hpp>
-#include <nall/utility.hpp>
-
-namespace nall {
-  //unsigned count() const;
-  template<typename T> struct has_count { enum { value = false }; };
-
-  //unsigned length() const;
-  template<typename T> struct has_length { enum { value = false }; };
-
-  //unsigned size() const;
-  template<typename T> struct has_size { enum { value = false }; };
-
-  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<has_count<T>>::type = 0) {
-    return object.count();
-  }
-
-  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<has_length<T>>::type = 0) {
-    return object.length();
-  }
-
-  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<has_size<T>>::type = 0) {
-    return object.size();
-  }
-
-  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<std::is_array<T>>::type = 0) {
-    return sizeof(T) / sizeof(typename std::remove_extent<T>::type);
-  }
-}
-
-#endif

bsnes/nall/config.hpp

@@ -1,123 +0,0 @@
-#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 { *(bool*)data };
-          case signed_t:   return { *(signed*)data };
-          case unsigned_t: return { *(unsigned*)data };
-          case double_t:   return { *(double*)data };
-          case string_t:   return { "\"", *(string*)data, "\"" };
-        }
-        return "???";
-      }
-
-      void set(string s) {
-        switch(type) {
-          case boolean_t:  *(bool*)data = (s == "true");     break;
-          case signed_t:   *(signed*)data = integer(s);      break;
-          case unsigned_t: *(unsigned*)data = decimal(s);    break;
-          case double_t:   *(double*)data = fp(s);           break;
-          case string_t:   s.trim("\""); *(string*)data = s; break;
-        }
-      }
-    };
-    linear_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++) {
-          if(auto position = qstrpos(line[i], "#")) line[i][position()] = 0;
-          if(!qstrpos(line[i], " = ")) continue;
-
-          lstring part;
-          part.qsplit(" = ", line[i]);
-          part[0].trim();
-          part[1].trim();
-
-          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.append(list[i].name, " = ", list[i].get());
-          if(list[i].desc != "") output.append(" # ", list[i].desc);
-          output.append("\r\n");
-          fp.print(output);
-        }
-
-        fp.close();
-        return true;
-      } else {
-        return false;
-      }
-    }
-  };
-}
-
-#endif

bsnes/nall/crc32.hpp

@@ -1,66 +0,0 @@
-#ifndef NALL_CRC32_HPP
-#define NALL_CRC32_HPP
-
-#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
-  };
-
-  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;
-  }
-}
-
-#endif

bsnes/nall/detect.hpp

@@ -1,30 +0,0 @@
-#ifndef NALL_DETECT_HPP
-#define NALL_DETECT_HPP
-
-/* Compiler detection */
-
-#if defined(__GNUC__)
-  #define COMPILER_GCC
-#elif defined(_MSC_VER)
-  #define COMPILER_VISUALC
-#endif
-
-/* Platform detection */
-
-#if defined(_WIN32)
-  #define PLATFORM_WIN
-#elif defined(__APPLE__)
-  #define PLATFORM_OSX
-#elif defined(linux) || defined(__sun__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
-  #define PLATFORM_X
-#endif
-
-/* Endian detection */
-
-#if defined(__i386__) || defined(__amd64__) || defined(_M_IX86) || defined(_M_AMD64)
-  #define ARCH_LSB
-#elif defined(__powerpc__) || defined(_M_PPC) || defined(__BIG_ENDIAN__)
-  #define ARCH_MSB
-#endif
-
-#endif

bsnes/nall/directory.hpp

@@ -1,152 +0,0 @@
-#ifndef NALL_DIRECTORY_HPP
-#define NALL_DIRECTORY_HPP
-
-#include <nall/foreach.hpp>
-#include <nall/sort.hpp>
-#include <nall/string.hpp>
-
-#if defined(_WIN32)
-  #include <nall/windows/utf8.hpp>
-#else
-  #include <dirent.h>
-  #include <stdio.h>
-  #include <sys/types.h>
-#endif
-
-namespace nall {
-
-struct directory {
-  static bool exists(const string &pathname);
-  static lstring folders(const string &pathname, const string &pattern = "*");
-  static lstring files(const string &pathname, const string &pattern = "*");
-  static lstring contents(const string &pathname, const string &pattern = "*");
-};
-
-#if defined(_WIN32)
-  inline bool directory::exists(const string &pathname) {
-    DWORD result = GetFileAttributes(utf16_t(pathname));
-    if(result == INVALID_FILE_ATTRIBUTES) return false;
-    return (result & FILE_ATTRIBUTE_DIRECTORY);
-  }
-
-  inline lstring directory::folders(const string &pathname, const string &pattern) {
-    lstring list;
-    string path = pathname;
-    path.transform("/", "\\");
-    if(!strend(path, "\\")) path.append("\\");
-    path.append("*");
-    HANDLE handle;
-    WIN32_FIND_DATA data;
-    handle = FindFirstFile(utf16_t(path), &data);
-    if(handle != INVALID_HANDLE_VALUE) {
-      if(wcscmp(data.cFileName, L".") && wcscmp(data.cFileName, L"..")) {
-        if(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-          string name = (const char*)utf8_t(data.cFileName);
-          if(wildcard(name, pattern)) list.append(name);
-        }
-      }
-      while(FindNextFile(handle, &data) != false) {
-        if(wcscmp(data.cFileName, L".") && wcscmp(data.cFileName, L"..")) {
-          if(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-            string name = (const char*)utf8_t(data.cFileName);
-            if(wildcard(name, pattern)) list.append(name);
-          }
-        }
-      }
-      FindClose(handle);
-    }
-    if(list.size() > 0) sort(&list[0], list.size());
-    foreach(name, list) name.append("/");  //must append after sorting
-    return list;
-  }
-
-  inline lstring directory::files(const string &pathname, const string &pattern) {
-    lstring list;
-    string path = pathname;
-    path.transform("/", "\\");
-    if(!strend(path, "\\")) path.append("\\");
-    path.append("*");
-    HANDLE handle;
-    WIN32_FIND_DATA data;
-    handle = FindFirstFile(utf16_t(path), &data);
-    if(handle != INVALID_HANDLE_VALUE) {
-      if((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
-        string name = (const char*)utf8_t(data.cFileName);
-        if(wildcard(name, pattern)) list.append(name);
-      }
-      while(FindNextFile(handle, &data) != false) {
-        if((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
-          string name = (const char*)utf8_t(data.cFileName);
-          if(wildcard(name, pattern)) list.append(name);
-        }
-      }
-      FindClose(handle);
-    }
-    if(list.size() > 0) sort(&list[0], list.size());
-    return list;
-  }
-
-  inline lstring directory::contents(const string &pathname, const string &pattern) {
-    lstring folders = directory::folders(pathname);  //pattern search of contents() should only filter files
-    lstring files = directory::files(pathname, pattern);
-    foreach(file, files) folders.append(file);
-    return folders;
-  }
-#else
-  inline bool directory::exists(const string &pathname) {
-    DIR *dp = opendir(pathname);
-    if(!dp) return false;
-    closedir(dp);
-    return true;
-  }
-
-  inline lstring directory::folders(const string &pathname, const string &pattern) {
-    lstring list;
-    DIR *dp;
-    struct dirent *ep;
-    dp = opendir(pathname);
-    if(dp) {
-      while(ep = readdir(dp)) {
-        if(!strcmp(ep->d_name, ".")) continue;
-        if(!strcmp(ep->d_name, "..")) continue;
-        if(ep->d_type & DT_DIR) {
-          if(wildcard(ep->d_name, pattern)) list.append(ep->d_name);
-        }
-      }
-      closedir(dp);
-    }
-    if(list.size() > 0) sort(&list[0], list.size());
-    foreach(name, list) name.append("/");  //must append after sorting
-    return list;
-  }
-
-  inline lstring directory::files(const string &pathname, const string &pattern) {
-    lstring list;
-    DIR *dp;
-    struct dirent *ep;
-    dp = opendir(pathname);
-    if(dp) {
-      while(ep = readdir(dp)) {
-        if(!strcmp(ep->d_name, ".")) continue;
-        if(!strcmp(ep->d_name, "..")) continue;
-        if((ep->d_type & DT_DIR) == 0) {
-          if(wildcard(ep->d_name, pattern)) list.append(ep->d_name);
-        }
-      }
-      closedir(dp);
-    }
-    if(list.size() > 0) sort(&list[0], list.size());
-    return list;
-  }
-
-  inline lstring directory::contents(const string &pathname, const string &pattern) {
-    lstring folders = directory::folders(pathname);  //pattern search of contents() should only filter files
-    lstring files = directory::files(pathname, pattern);
-    foreach(file, files) folders.append(file);
-    return folders;
-  }
-#endif
-
-}
-
-#endif

bsnes/nall/dl.hpp

@@ -1,115 +0,0 @@
-#ifndef NALL_DL_HPP
-#define NALL_DL_HPP
-
-//dynamic linking support
-
-#include <nall/detect.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-#include <nall/utility.hpp>
-
-#if defined(PLATFORM_X) || defined(PLATFORM_OSX)
-  #include <dlfcn.h>
-#elif defined(PLATFORM_WIN)
-  #include <windows.h>
-  #include <nall/windows/utf8.hpp>
-#endif
-
-namespace nall {
-  struct library {
-    bool opened() const { return handle; }
-    bool open(const char*, const char* = "");
-    bool open_absolute(const char*);
-    void* sym(const char*);
-    void close();
-
-    library() : handle(0) {}
-    ~library() { close(); }
-
-    library& operator=(const library&) = delete;
-    library(const library&) = delete;
-
-  private:
-    uintptr_t handle;
-  };
-
-  #if defined(PLATFORM_X)
-  inline bool library::open(const char *name, const char *path) {
-    if(handle) close();
-    handle = (uintptr_t)dlopen(string(path, *path && !strend(path, "/") ? "/" : "", "lib", name, ".so"), RTLD_LAZY);
-    if(!handle) handle = (uintptr_t)dlopen(string("/usr/local/lib/lib", name, ".so"), RTLD_LAZY);
-    return handle;
-  }
-
-  inline bool library::open_absolute(const char *name) {
-    if(handle) close();
-    handle = (uintptr_t)dlopen(name, RTLD_LAZY);
-    return handle;
-  }
-
-  inline void* library::sym(const char *name) {
-    if(!handle) return 0;
-    return dlsym((void*)handle, name);
-  }
-
-  inline void library::close() {
-    if(!handle) return;
-    dlclose((void*)handle);
-    handle = 0;
-  }
-  #elif defined(PLATFORM_OSX)
-  inline bool library::open(const char *name, const char *path) {
-    if(handle) close();
-    handle = (uintptr_t)dlopen(string(path, *path && !strend(path, "/") ? "/" : "", "lib", name, ".dylib"), RTLD_LAZY);
-    if(!handle) handle = (uintptr_t)dlopen(string("/usr/local/lib/lib", name, ".dylib"), RTLD_LAZY);
-    return handle;
-  }
-
-  inline bool library::open_absolute(const char *name) {
-    if(handle) close();
-    handle = (uintptr_t)dlopen(name, RTLD_LAZY);
-    return handle;
-  }
-
-  inline void* library::sym(const char *name) {
-    if(!handle) return 0;
-    return dlsym((void*)handle, name);
-  }
-
-  inline void library::close() {
-    if(!handle) return;
-    dlclose((void*)handle);
-    handle = 0;
-  }
-  #elif defined(PLATFORM_WIN)
-  inline bool library::open(const char *name, const char *path) {
-    if(handle) close();
-    string filepath(path, *path && !strend(path, "/") && !strend(path, "\\") ? "\\" : "", name, ".dll");
-    handle = (uintptr_t)LoadLibraryW(utf16_t(filepath));
-    return handle;
-  }
-
-  inline bool library::open_absolute(const char *name) {
-    if(handle) close();
-    handle = (uintptr_t)LoadLibraryW(utf16_t(name));
-    return handle;
-  }
-
-  inline void* library::sym(const char *name) {
-    if(!handle) return 0;
-    return (void*)GetProcAddress((HMODULE)handle, name);
-  }
-
-  inline void library::close() {
-    if(!handle) return;
-    FreeLibrary((HMODULE)handle);
-    handle = 0;
-  }
-  #else
-  inline bool library::open(const char*, const char*) { return false; }
-  inline void* library::sym(const char*) { return 0; }
-  inline void library::close() {}
-  #endif
-};
-
-#endif

bsnes/nall/dsp/buffer.hpp

@@ -1,36 +0,0 @@
-#ifdef NALL_DSP_INTERNAL_HPP
-
-struct Buffer {
-  double *sample[2];
-  uint16_t rdoffset;
-  uint16_t wroffset;
-
-  inline double& read(bool channel, signed offset = 0) {
-    return sample[channel][(uint16_t)(rdoffset + offset)];
-  }
-
-  inline double& write(bool channel, signed offset = 0) {
-    return sample[channel][(uint16_t)(wroffset + offset)];
-  }
-
-  inline void clear() {
-    for(unsigned n = 0; n < 65536; n++) {
-      sample[0][n] = 0;
-      sample[1][n] = 0;
-    }
-    rdoffset = 0;
-    wroffset = 0;
-  }
-
-  Buffer() {
-    sample[0] = new double[65536];
-    sample[1] = new double[65536];
-  }
-
-  ~Buffer() {
-    delete[] sample[0];
-    delete[] sample[1];
-  }
-};
-
-#endif

bsnes/nall/dsp/core.hpp

@@ -1,154 +0,0 @@
-#ifdef NALL_DSP_INTERNAL_HPP
-
-#include <math.h>
-#include <nall/stdint.hpp>
-
-namespace nall {
-
-struct DSP {
-  enum class Resampler : unsigned {
-    Point,
-    Linear,
-    Cosine,
-    Cubic,
-    Hermite,
-    Average,
-  };
-
-  inline void setPrecision(unsigned precision);
-  inline void setFrequency(double frequency);  //inputFrequency
-  inline void setVolume(double volume);
-  inline void setBalance(double balance);
-
-  inline void setResampler(Resampler resampler);
-  inline void setResamplerFrequency(double frequency);  //outputFrequency
-
-  inline void sample(signed lchannel, signed rchannel);
-  inline bool pending();
-  inline void read(signed &lchannel, signed &rchannel);
-
-  inline void clear();
-  inline DSP();
-  inline ~DSP();
-
-protected:
-  struct Settings {
-    unsigned precision;
-    double frequency;
-    double volume;
-    double balance;
-    //internal
-    double intensity;
-  } settings;
-
-  struct ResamplerSettings {
-    Resampler engine;
-    double frequency;
-    //internal
-    double fraction;
-    double step;
-  } resampler;
-
-  inline void resamplerRun();
-  inline void resamplerWrite(double lchannel, double rchannel);
-
-  inline void resamplePoint();
-  inline void resampleLinear();
-  inline void resampleCosine();
-  inline void resampleCubic();
-  inline void resampleHermite();
-  inline void resampleAverage();
-
-  #include "buffer.hpp"
-  Buffer buffer;
-  Buffer output;
-
-  inline void adjustVolume();
-  inline void adjustBalance();
-  inline signed clamp(const unsigned bits, const signed x);
-};
-
-#include "settings.hpp"
-
-void DSP::sample(signed lchannel, signed rchannel) {
-  buffer.write(0) = (double)lchannel / settings.intensity;
-  buffer.write(1) = (double)rchannel / settings.intensity;
-  buffer.wroffset++;
-  resamplerRun();
-}
-
-bool DSP::pending() {
-  return output.rdoffset != output.wroffset;
-}
-
-void DSP::read(signed &lchannel, signed &rchannel) {
-  adjustVolume();
-  adjustBalance();
-
-  lchannel = clamp(settings.precision, output.read(0) * settings.intensity);
-  rchannel = clamp(settings.precision, output.read(1) * settings.intensity);
-  output.rdoffset++;
-}
-
-void DSP::resamplerRun() {
-  switch(resampler.engine) {
-  case Resampler::Point:   return resamplePoint();
-  case Resampler::Linear:  return resampleLinear();
-  case Resampler::Cosine:  return resampleCosine();
-  case Resampler::Cubic:   return resampleCubic();
-  case Resampler::Hermite: return resampleHermite();
-  case Resampler::Average: return resampleAverage();
-  }
-}
-
-void DSP::resamplerWrite(double lchannel, double rchannel) {
-  output.write(0) = lchannel;
-  output.write(1) = rchannel;
-  output.wroffset++;
-}
-
-#include "resample/point.hpp"
-#include "resample/linear.hpp"
-#include "resample/cosine.hpp"
-#include "resample/cubic.hpp"
-#include "resample/hermite.hpp"
-#include "resample/average.hpp"
-
-void DSP::adjustVolume() {
-  output.read(0) *= settings.volume;
-  output.read(1) *= settings.volume;
-}
-
-void DSP::adjustBalance() {
-  if(settings.balance < 0.0) output.read(1) *= 1.0 + settings.balance;
-  if(settings.balance > 0.0) output.read(0) *= 1.0 - settings.balance;
-}
-
-signed DSP::clamp(const unsigned bits, const signed x) {
-  const signed b = 1U << (bits - 1);
-  const signed m = (1U << (bits - 1)) - 1;
-  return (x > m) ? m : (x < -b) ? -b : x;
-}
-
-void DSP::clear() {
-  resampler.fraction = 0.0;
-  buffer.clear();
-  output.clear();
-}
-
-DSP::DSP() {
-  setPrecision(16);
-  setFrequency(44100.0);
-  setVolume(1.0);
-  setBalance(0.0);
-  setResampler(Resampler::Hermite);
-  setResamplerFrequency(44100.0);
-  clear();
-}
-
-DSP::~DSP() {
-}
-
-}
-
-#endif

bsnes/nall/dsp/resample/average.hpp

@@ -1,28 +0,0 @@
-#ifdef NALL_DSP_INTERNAL_HPP
-
-void DSP::resampleAverage() {
-  //can only average if input frequency >= output frequency
-  if(resampler.step < 1.0) return resampleHermite();
-
-  resampler.fraction += 1.0;
-
-  double scalar = 1.0;
-  if(resampler.fraction > resampler.step) scalar = 1.0 - (resampler.fraction - resampler.step);
-
-  output.write(0) += buffer.read(0) * scalar;
-  output.write(1) += buffer.read(1) * scalar;
-
-  if(resampler.fraction >= resampler.step) {
-    output.write(0) /= resampler.step;
-    output.write(1) /= resampler.step;
-    output.wroffset++;
-
-    resampler.fraction -= resampler.step;
-    output.write(0) = buffer.read(0) * resampler.fraction;
-    output.write(1) = buffer.read(1) * resampler.fraction;
-  }
-
-  buffer.rdoffset++;
-}
-
-#endif

bsnes/nall/dsp/resample/cosine.hpp

@@ -1,25 +0,0 @@
-#ifdef NALL_DSP_INTERNAL_HPP
-
-void DSP::resampleCosine() {
-  while(resampler.fraction <= 1.0) {
-    double channel[2];
-
-    for(unsigned n = 0; n < 2; n++) {
-      double a = buffer.read(n, -1);
-      double b = buffer.read(n, -0);
-
-      double mu = resampler.fraction;
-      mu = (1.0 - cos(mu * 3.14159265)) / 2.0;
-
-      channel[n] = a * (1.0 - mu) + b * mu;
-    }
-
-    resamplerWrite(channel[0], channel[1]);
-    resampler.fraction += resampler.step;
-  }
-
-  buffer.rdoffset++;
-  resampler.fraction -= 1.0;
-}
-
-#endif

bsnes/nall/dsp/resample/cubic.hpp

@@ -1,31 +0,0 @@
-#ifdef NALL_DSP_INTERNAL_HPP
-
-void DSP::resampleCubic() {
-  while(resampler.fraction <= 1.0) {
-    double channel[2];
-
-    for(unsigned n = 0; n < 2; n++) {
-      double a = buffer.read(n, -3);
-      double b = buffer.read(n, -2);
-      double c = buffer.read(n, -1);
-      double d = buffer.read(n, -0);
-
-      double mu = resampler.fraction;
-
-      double A = d - c - a + b;
-      double B = a - b - A;
-      double C = c - a;
-      double D = b;
-
-      channel[n] = A * (mu * 3) + B * (mu * 2) + C * mu + D;
-    }
-
-    resamplerWrite(channel[0], channel[1]);
-    resampler.fraction += resampler.step;
-  }
-
-  buffer.rdoffset++;
-  resampler.fraction -= 1.0;
-}
-
-#endif

bsnes/nall/dsp/resample/hermite.hpp

@@ -1,43 +0,0 @@
-#ifdef NALL_DSP_INTERNAL_HPP
-
-void DSP::resampleHermite() {
-  while(resampler.fraction <= 1.0) {
-    double channel[2];
-
-    for(unsigned n = 0; n < 2; n++) {
-      double a = buffer.read(n, -3);
-      double b = buffer.read(n, -2);
-      double c = buffer.read(n, -1);
-      double d = buffer.read(n, -0);
-
-      const double tension = 0.0;  //-1 = low, 0 = normal, +1 = high
-      const double bias = 0.0;  //-1 = left, 0 = even, +1 = right
-
-      double mu1, mu2, mu3, m0, m1, a0, a1, a2, a3;
-
-      mu1 = resampler.fraction;
-      mu2 = mu1 * mu1;
-      mu3 = mu2 * mu1;
-
-      m0  = (b - a) * (1.0 + bias) * (1.0 - tension) / 2.0;
-      m0 += (c - b) * (1.0 - bias) * (1.0 - tension) / 2.0;
-      m1  = (c - b) * (1.0 + bias) * (1.0 - tension) / 2.0;
-      m1 += (d - c) * (1.0 - bias) * (1.0 - tension) / 2.0;
-
-      a0 = +2 * mu3 - 3 * mu2 + 1;
-      a1 =      mu3 - 2 * mu2 + mu1;
-      a2 =      mu3 -     mu2;
-      a3 = -2 * mu3 + 3 * mu2;
-
-      channel[n] = (a0 * b) + (a1 * m0) + (a2 * m1) + (a3 * c);
-    }
-
-    resamplerWrite(channel[0], channel[1]);
-    resampler.fraction += resampler.step;
-  }
-
-  buffer.rdoffset++;
-  resampler.fraction -= 1.0;
-}
-
-#endif

bsnes/nall/dsp/resample/linear.hpp

@@ -1,24 +0,0 @@
-#ifdef NALL_DSP_INTERNAL_HPP
-
-void DSP::resampleLinear() {
-  while(resampler.fraction <= 1.0) {
-    double channel[2];
-
-    for(unsigned n = 0; n < 2; n++) {
-      double a = buffer.read(n, -1);
-      double b = buffer.read(n, -0);
-
-      double mu = resampler.fraction;
-
-      channel[n] = a * (1.0 - mu) + b * mu;
-    }
-
-    resamplerWrite(channel[0], channel[1]);
-    resampler.fraction += resampler.step;
-  }
-
-  buffer.rdoffset++;
-  resampler.fraction -= 1.0;
-}
-
-#endif

bsnes/nall/dsp/resample/point.hpp

@@ -1,24 +0,0 @@
-#ifdef NALL_DSP_INTERNAL_HPP
-
-void DSP::resamplePoint() {
-  while(resampler.fraction <= 1.0) {
-    double channel[2];
-
-    for(unsigned n = 0; n < 2; n++) {
-      double a = buffer.read(n, -1);
-      double b = buffer.read(n, -0);
-
-      double mu = resampler.fraction;
-
-      channel[n] = mu < 0.5 ? a : b;
-    }
-
-    resamplerWrite(channel[0], channel[1]);
-    resampler.fraction += resampler.step;
-  }
-
-  buffer.rdoffset++;
-  resampler.fraction -= 1.0;
-}
-
-#endif

bsnes/nall/dsp/settings.hpp

@@ -1,32 +0,0 @@
-#ifdef NALL_DSP_INTERNAL_HPP
-
-void DSP::setPrecision(unsigned precision) {
-  settings.precision = precision;
-  settings.intensity = 1 << (settings.precision - 1);
-}
-
-void DSP::setFrequency(double frequency) {
-  settings.frequency = frequency;
-  resampler.fraction = 0;
-  resampler.step = settings.frequency / resampler.frequency;
-}
-
-void DSP::setVolume(double volume) {
-  settings.volume = volume;
-}
-
-void DSP::setBalance(double balance) {
-  settings.balance = balance;
-}
-
-void DSP::setResampler(Resampler engine) {
-  resampler.engine = engine;
-}
-
-void DSP::setResamplerFrequency(double frequency) {
-  resampler.frequency = frequency;
-  resampler.fraction = 0;
-  resampler.step = settings.frequency / resampler.frequency;
-}
-
-#endif

bsnes/nall/endian.hpp

@@ -1,38 +0,0 @@
-#ifndef NALL_ENDIAN_HPP
-#define NALL_ENDIAN_HPP
-
-#if !defined(ARCH_MSB)
-  //little-endian: uint8_t[] { 0x01, 0x02, 0x03, 0x04 } == 0x04030201
-  #define order_lsb2(a,b)             a,b
-  #define order_lsb3(a,b,c)           a,b,c
-  #define order_lsb4(a,b,c,d)         a,b,c,d
-  #define order_lsb5(a,b,c,d,e)       a,b,c,d,e
-  #define order_lsb6(a,b,c,d,e,f)     a,b,c,d,e,f
-  #define order_lsb7(a,b,c,d,e,f,g)   a,b,c,d,e,f,g
-  #define order_lsb8(a,b,c,d,e,f,g,h) a,b,c,d,e,f,g,h
-  #define order_msb2(a,b)             b,a
-  #define order_msb3(a,b,c)           c,b,a
-  #define order_msb4(a,b,c,d)         d,c,b,a
-  #define order_msb5(a,b,c,d,e)       e,d,c,b,a
-  #define order_msb6(a,b,c,d,e,f)     f,e,d,c,b,a
-  #define order_msb7(a,b,c,d,e,f,g)   g,f,e,d,c,b,a
-  #define order_msb8(a,b,c,d,e,f,g,h) h,g,f,e,d,c,b,a
-#else
-  //big-endian:    uint8_t[] { 0x01, 0x02, 0x03, 0x04 } == 0x01020304
-  #define order_lsb2(a,b)             b,a
-  #define order_lsb3(a,b,c)           c,b,a
-  #define order_lsb4(a,b,c,d)         d,c,b,a
-  #define order_lsb5(a,b,c,d,e)       e,d,c,b,a
-  #define order_lsb6(a,b,c,d,e,f)     f,e,d,c,b,a
-  #define order_lsb7(a,b,c,d,e,f,g)   g,f,e,d,c,b,a
-  #define order_lsb8(a,b,c,d,e,f,g,h) h,g,f,e,d,c,b,a
-  #define order_msb2(a,b)             a,b
-  #define order_msb3(a,b,c)           a,b,c
-  #define order_msb4(a,b,c,d)         a,b,c,d
-  #define order_msb5(a,b,c,d,e)       a,b,c,d,e
-  #define order_msb6(a,b,c,d,e,f)     a,b,c,d,e,f
-  #define order_msb7(a,b,c,d,e,f,g)   a,b,c,d,e,f,g
-  #define order_msb8(a,b,c,d,e,f,g,h) a,b,c,d,e,f,g,h
-#endif
-
-#endif

bsnes/nall/file.hpp

@@ -1,284 +0,0 @@
-#ifndef NALL_FILE_HPP
-#define NALL_FILE_HPP
-
-#include <nall/platform.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-#include <nall/utility.hpp>
-#include <nall/windows/utf8.hpp>
-
-namespace nall {
-  inline FILE* fopen_utf8(const string &utf8_filename, const char *mode) {
-    #if !defined(_WIN32)
-    return fopen(utf8_filename, mode);
-    #else
-    return _wfopen(utf16_t(utf8_filename), utf16_t(mode));
-    #endif
-  }
-
-  class file {
-  public:
-    enum class mode : unsigned { read, write, readwrite, writeread };
-    enum class index : unsigned { absolute, relative };
-    enum class time : unsigned { create, modify, access };
-
-    static bool read(const string &filename, uint8_t *&data, unsigned &size) {
-      file fp;
-      if(fp.open(filename, mode::read) == false) return false;
-      size = fp.size();
-      data = new uint8_t[size];
-      fp.read(data, size);
-      fp.close();
-      return true;
-    }
-
-    static bool read(const string &filename, const uint8_t *&data, unsigned &size) {
-      return file::read(filename, (uint8_t*&)data, size);
-    }
-
-    static bool write(const string &filename, const uint8_t *data, unsigned size) {
-      file fp;
-      if(fp.open(filename, mode::write) == false) return false;
-      fp.write(data, size);
-      fp.close();
-      return true;
-    }
-
-    uint8_t read() {
-      if(!fp) return 0xff;                       //file not open
-      if(file_mode == mode::write) return 0xff;  //reads not permitted
-      if(file_offset >= file_size) return 0xff;  //cannot read past end of file
-      buffer_sync();
-      return buffer[(file_offset++) & buffer_mask];
-    }
-
-    uintmax_t readl(unsigned length = 1) {
-      uintmax_t data = 0;
-      for(int i = 0; i < length; i++) {
-        data |= (uintmax_t)read() << (i << 3);
-      }
-      return data;
-    }
-
-    uintmax_t readm(unsigned length = 1) {
-      uintmax_t data = 0;
-      while(length--) {
-        data <<= 8;
-        data |= read();
-      }
-      return data;
-    }
-
-    void read(uint8_t *buffer, unsigned length) {
-      while(length--) *buffer++ = read();
-    }
-
-    void write(uint8_t data) {
-      if(!fp) return;                      //file not open
-      if(file_mode == mode::read) return;  //writes not permitted
-      buffer_sync();
-      buffer[(file_offset++) & buffer_mask] = data;
-      buffer_dirty = true;
-      if(file_offset > file_size) file_size = file_offset;
-    }
-
-    void writel(uintmax_t data, unsigned length = 1) {
-      while(length--) {
-        write(data);
-        data >>= 8;
-      }
-    }
-
-    void writem(uintmax_t data, unsigned length = 1) {
-      for(int i = length - 1; i >= 0; i--) {
-        write(data >> (i << 3));
-      }
-    }
-
-    void write(const uint8_t *buffer, unsigned length) {
-      while(length--) write(*buffer++);
-    }
-
-    template<typename... Args> void print(Args... args) {
-      string data(args...);
-      const char *p = data;
-      while(*p) write(*p++);
-    }
-
-    void flush() {
-      buffer_flush();
-      fflush(fp);
-    }
-
-    void seek(int offset, index index_ = index::absolute) {
-      if(!fp) return;  //file not open
-      buffer_flush();
-
-      uintmax_t req_offset = file_offset;
-      switch(index_) {
-        case index::absolute: req_offset  = offset; break;
-        case index::relative: req_offset += offset; break;
-      }
-
-      if(req_offset < 0) req_offset = 0;  //cannot seek before start of file
-      if(req_offset > file_size) {
-        if(file_mode == mode::read) {     //cannot seek past end of file
-          req_offset = file_size;
-        } else {                          //pad file to requested location
-          file_offset = file_size;
-          while(file_size < req_offset) write(0x00);
-        }
-      }
-
-      file_offset = req_offset;
-    }
-
-    int offset() {
-      if(!fp) return -1;  //file not open
-      return file_offset;
-    }
-
-    int size() {
-      if(!fp) return -1;  //file not open
-      return file_size;
-    }
-
-    bool truncate(unsigned size) {
-      if(!fp) return false;  //file not open
-      #if !defined(_WIN32)
-      return ftruncate(fileno(fp), size) == 0;
-      #else
-      return _chsize(fileno(fp), size) == 0;
-      #endif
-    }
-
-    bool end() {
-      if(!fp) return true;  //file not open
-      return file_offset >= file_size;
-    }
-
-    static bool exists(const string &filename) {
-      #if !defined(_WIN32)
-      struct stat64 data;
-      return stat64(filename, &data) == 0;
-      #else
-      struct __stat64 data;
-      return _wstat64(utf16_t(filename), &data) == 0;
-      #endif
-    }
-
-    static uintmax_t size(const string &filename) {
-      #if !defined(_WIN32)
-      struct stat64 data;
-      stat64(filename, &data);
-      #else
-      struct __stat64 data;
-      _wstat64(utf16_t(filename), &data);
-      #endif
-      return S_ISREG(data.st_mode) ? data.st_size : 0u;
-    }
-
-    static time_t timestamp(const string &filename, file::time mode = file::time::create) {
-      #if !defined(_WIN32)
-      struct stat64 data;
-      stat64(filename, &data);
-      #else
-      struct __stat64 data;
-      _wstat64(utf16_t(filename), &data);
-      #endif
-      switch(mode) { default:
-        case file::time::create: return data.st_ctime;
-        case file::time::modify: return data.st_mtime;
-        case file::time::access: return data.st_atime;
-      }
-    }
-
-    bool open() {
-      return fp;
-    }
-
-    bool open(const string &filename, mode mode_) {
-      if(fp) return false;
-
-      switch(file_mode = mode_) {
-        #if !defined(_WIN32)
-        case mode::read:      fp = fopen(filename, "rb" ); break;
-        case mode::write:     fp = fopen(filename, "wb+"); break;  //need read permission for buffering
-        case mode::readwrite: fp = fopen(filename, "rb+"); break;
-        case mode::writeread: fp = fopen(filename, "wb+"); break;
-        #else
-        case mode::read:      fp = _wfopen(utf16_t(filename), L"rb" ); break;
-        case mode::write:     fp = _wfopen(utf16_t(filename), L"wb+"); break;
-        case mode::readwrite: fp = _wfopen(utf16_t(filename), L"rb+"); break;
-        case mode::writeread: fp = _wfopen(utf16_t(filename), L"wb+"); break;
-        #endif
-      }
-      if(!fp) return false;
-      buffer_offset = -1;  //invalidate buffer
-      file_offset = 0;
-      fseek(fp, 0, SEEK_END);
-      file_size = ftell(fp);
-      fseek(fp, 0, SEEK_SET);
-      return true;
-    }
-
-    void close() {
-      if(!fp) return;
-      buffer_flush();
-      fclose(fp);
-      fp = 0;
-    }
-
-    file() {
-      memset(buffer, 0, sizeof buffer);
-      buffer_offset = -1;
-      buffer_dirty = false;
-      fp = 0;
-      file_offset = 0;
-      file_size = 0;
-      file_mode = mode::read;
-    }
-
-    ~file() {
-      close();
-    }
-
-    file& operator=(const file&) = delete;
-    file(const file&) = delete;
-
-  private:
-    enum { buffer_size = 1 << 12, buffer_mask = buffer_size - 1 };
-    char buffer[buffer_size];
-    int buffer_offset;
-    bool buffer_dirty;
-    FILE *fp;
-    unsigned file_offset;
-    unsigned file_size;
-    mode file_mode;
-
-    void buffer_sync() {
-      if(!fp) return;  //file not open
-      if(buffer_offset != (file_offset & ~buffer_mask)) {
-        buffer_flush();
-        buffer_offset = file_offset & ~buffer_mask;
-        fseek(fp, buffer_offset, SEEK_SET);
-        unsigned length = (buffer_offset + buffer_size) <= file_size ? buffer_size : (file_size & buffer_mask);
-        if(length) unsigned unused = fread(buffer, 1, length, fp);
-      }
-    }
-
-    void buffer_flush() {
-      if(!fp) return;                      //file not open
-      if(file_mode == mode::read) return;  //buffer cannot be written to
-      if(buffer_offset < 0) return;        //buffer unused
-      if(buffer_dirty == false) return;    //buffer unmodified since read
-      fseek(fp, buffer_offset, SEEK_SET);
-      unsigned length = (buffer_offset + buffer_size) <= file_size ? buffer_size : (file_size & buffer_mask);
-      if(length) unsigned unused = fwrite(buffer, 1, length, fp);
-      buffer_offset = -1;                  //invalidate buffer
-      buffer_dirty = false;
-    }
-  };
-}
-
-#endif

bsnes/nall/filemap.hpp

@@ -1,212 +0,0 @@
-#ifndef NALL_FILEMAP_HPP
-#define NALL_FILEMAP_HPP
-
-#include <nall/stdint.hpp>
-#include <nall/windows/utf8.hpp>
-
-#include <stdio.h>
-#include <stdlib.h>
-#if defined(_WIN32)
-  #include <windows.h>
-#else
-  #include <fcntl.h>
-  #include <unistd.h>
-  #include <sys/mman.h>
-  #include <sys/stat.h>
-  #include <sys/types.h>
-#endif
-
-namespace nall {
-  class filemap {
-  public:
-    enum class mode : unsigned { read, write, readwrite, writeread };
-
-    bool open() const { return p_open(); }
-    bool open(const char *filename, mode mode_) { return p_open(filename, mode_); }
-    void close() { return p_close(); }
-    unsigned size() const { return p_size; }
-    uint8_t* data() { return p_handle; }
-    const uint8_t* data() const { return p_handle; }
-    filemap() : p_size(0), p_handle(0) { p_ctor(); }
-    filemap(const char *filename, mode mode_) : p_size(0), p_handle(0) { p_ctor(); p_open(filename, mode_); }
-    ~filemap() { p_dtor(); }
-
-  private:
-    unsigned p_size;
-    uint8_t *p_handle;
-
-    #if defined(_WIN32)
-    //=============
-    //MapViewOfFile
-    //=============
-
-    HANDLE p_filehandle, p_maphandle;
-
-    bool p_open() const {
-      return p_handle;
-    }
-
-    bool p_open(const char *filename, mode mode_) {
-      if(file::exists(filename) && file::size(filename) == 0) {
-        p_handle = 0;
-        p_size = 0;
-        return true;
-      }
-
-      int desired_access, creation_disposition, flprotect, map_access;
-
-      switch(mode_) {
-        default: return false;
-        case mode::read:
-          desired_access = GENERIC_READ;
-          creation_disposition = OPEN_EXISTING;
-          flprotect = PAGE_READONLY;
-          map_access = FILE_MAP_READ;
-          break;
-        case mode::write:
-          //write access requires read access
-          desired_access = GENERIC_WRITE;
-          creation_disposition = CREATE_ALWAYS;
-          flprotect = PAGE_READWRITE;
-          map_access = FILE_MAP_ALL_ACCESS;
-          break;
-        case mode::readwrite:
-          desired_access = GENERIC_READ | GENERIC_WRITE;
-          creation_disposition = OPEN_EXISTING;
-          flprotect = PAGE_READWRITE;
-          map_access = FILE_MAP_ALL_ACCESS;
-          break;
-        case mode::writeread:
-          desired_access = GENERIC_READ | GENERIC_WRITE;
-          creation_disposition = CREATE_NEW;
-          flprotect = PAGE_READWRITE;
-          map_access = FILE_MAP_ALL_ACCESS;
-          break;
-      }
-
-      p_filehandle = CreateFileW(utf16_t(filename), desired_access, FILE_SHARE_READ, NULL,
-        creation_disposition, FILE_ATTRIBUTE_NORMAL, NULL);
-      if(p_filehandle == INVALID_HANDLE_VALUE) return false;
-
-      p_size = GetFileSize(p_filehandle, NULL);
-
-      p_maphandle = CreateFileMapping(p_filehandle, NULL, flprotect, 0, p_size, NULL);
-      if(p_maphandle == INVALID_HANDLE_VALUE) {
-        CloseHandle(p_filehandle);
-        p_filehandle = INVALID_HANDLE_VALUE;
-        return false;
-      }
-
-      p_handle = (uint8_t*)MapViewOfFile(p_maphandle, map_access, 0, 0, p_size);
-      return p_handle;
-    }
-
-    void p_close() {
-      if(p_handle) {
-        UnmapViewOfFile(p_handle);
-        p_handle = 0;
-      }
-
-      if(p_maphandle != INVALID_HANDLE_VALUE) {
-        CloseHandle(p_maphandle);
-        p_maphandle = INVALID_HANDLE_VALUE;
-      }
-
-      if(p_filehandle != INVALID_HANDLE_VALUE) {
-        CloseHandle(p_filehandle);
-        p_filehandle = INVALID_HANDLE_VALUE;
-      }
-    }
-
-    void p_ctor() {
-      p_filehandle = INVALID_HANDLE_VALUE;
-      p_maphandle  = INVALID_HANDLE_VALUE;
-    }
-
-    void p_dtor() {
-      close();
-    }
-
-    #else
-    //====
-    //mmap
-    //====
-
-    int p_fd;
-
-    bool p_open() const {
-      return p_handle;
-    }
-
-    bool p_open(const char *filename, mode mode_) {
-      if(file::exists(filename) && file::size(filename) == 0) {
-        p_handle = 0;
-        p_size = 0;
-        return true;
-      }
-
-      int open_flags, mmap_flags;
-
-      switch(mode_) {
-        default: return false;
-        case mode::read:
-          open_flags = O_RDONLY;
-          mmap_flags = PROT_READ;
-          break;
-        case mode::write:
-          open_flags = O_RDWR | O_CREAT;  //mmap() requires read access
-          mmap_flags = PROT_WRITE;
-          break;
-        case mode::readwrite:
-          open_flags = O_RDWR;
-          mmap_flags = PROT_READ | PROT_WRITE;
-          break;
-        case mode::writeread:
-          open_flags = O_RDWR | O_CREAT;
-          mmap_flags = PROT_READ | PROT_WRITE;
-          break;
-      }
-
-      p_fd = ::open(filename, open_flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
-      if(p_fd < 0) return false;
-
-      struct stat p_stat;
-      fstat(p_fd, &p_stat);
-      p_size = p_stat.st_size;
-
-      p_handle = (uint8_t*)mmap(0, p_size, mmap_flags, MAP_SHARED, p_fd, 0);
-      if(p_handle == MAP_FAILED) {
-        p_handle = 0;
-        ::close(p_fd);
-        p_fd = -1;
-        return false;
-      }
-
-      return p_handle;
-    }
-
-    void p_close() {
-      if(p_handle) {
-        munmap(p_handle, p_size);
-        p_handle = 0;
-      }
-
-      if(p_fd >= 0) {
-        ::close(p_fd);
-        p_fd = -1;
-      }
-    }
-
-    void p_ctor() {
-      p_fd = -1;
-    }
-
-    void p_dtor() {
-      p_close();
-    }
-
-    #endif
-  };
-}
-
-#endif

bsnes/nall/foreach.hpp

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

bsnes/nall/function.hpp

@@ -1,60 +0,0 @@
-#ifndef NALL_FUNCTION_HPP
-#define NALL_FUNCTION_HPP
-
-namespace nall {
-  template<typename T> class function;
-
-  template<typename R, typename... P> class function<R (P...)> {
-    struct container {
-      virtual R operator()(P... p) const = 0;
-      virtual container* copy() const = 0;
-      virtual ~container() {}
-    } *callback;
-
-    struct global : container {
-      R (*function)(P...);
-      R operator()(P... p) const { return function(std::forward<P>(p)...); }
-      container* copy() const { return new global(function); }
-      global(R (*function)(P...)) : function(function) {}
-    };
-
-    template<typename C> struct member : container {
-      R (C::*function)(P...);
-      C *object;
-      R operator()(P... p) const { return (object->*function)(std::forward<P>(p)...); }
-      container* copy() const { return new member(function, object); }
-      member(R (C::*function)(P...), C *object) : function(function), object(object) {}
-    };
-
-    template<typename L> struct lambda : container {
-      mutable L object;
-      R operator()(P... p) const { return object(std::forward<P>(p)...); }
-      container* copy() const { return new lambda(object); }
-      lambda(const L& object) : object(object) {}
-    };
-
-  public:
-    operator bool() const { return callback; }
-    R operator()(P... p) const { return (*callback)(std::forward<P>(p)...); }
-    void reset() { if(callback) { delete callback; callback = 0; } }
-
-    function& operator=(const function &source) {
-      if(this != &source) {
-        if(callback) { delete callback; callback = 0; }
-        if(source.callback) callback = source.callback->copy();
-      }
-      return *this;
-    }
-
-    function(const function &source) : callback(0) { operator=(source); }
-    function() : callback(0) {}
-    function(void *function) : callback(0) { if(function) callback = new global((R (*)(P...))function); }
-    function(R (*function)(P...)) { callback = new global(function); }
-    template<typename C> function(R (C::*function)(P...), C *object) { callback = new member<C>(function, object); }
-    template<typename C> function(R (C::*function)(P...) const, C *object) { callback = new member<C>((R (C::*)(P...))function, object); }
-    template<typename L> function(const L& object) { callback = new lambda<L>(object); }
-    ~function() { if(callback) delete callback; }
-  };
-}
-
-#endif

bsnes/nall/gameboy/cartridge.hpp

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

bsnes/nall/gzip.hpp

@@ -1,87 +0,0 @@
-#ifndef NALL_GZIP_HPP
-#define NALL_GZIP_HPP
-
-#include <nall/file.hpp>
-#include <nall/inflate.hpp>
-
-namespace nall {
-
-struct gzip {
-  string filename;
-  uint8_t *data;
-  unsigned size;
-
-  bool decompress(const string &filename);
-  bool decompress(const uint8_t *data, unsigned size);
-
-  gzip();
-  ~gzip();
-};
-
-bool gzip::decompress(const string &filename) {
-  uint8_t *data;
-  unsigned size;
-  if(file::read(filename, data, size) == false) return false;
-  bool result = decompress(data, size);
-  delete[] data;
-  return result;
-}
-
-bool gzip::decompress(const uint8_t *data, unsigned size) {
-  if(size < 18) return false;
-  if(data[0] != 0x1f) return false;
-  if(data[1] != 0x8b) return false;
-  unsigned cm = data[2];
-  unsigned flg = data[3];
-  unsigned mtime = data[4];
-  mtime |= data[5] << 8;
-  mtime |= data[6] << 16;
-  mtime |= data[7] << 24;
-  unsigned xfl = data[8];
-  unsigned os = data[9];
-  unsigned p = 10;
-  unsigned isize = data[size - 4];
-  isize |= data[size - 3] << 8;
-  isize |= data[size - 2] << 16;
-  isize |= data[size - 1] << 24;
-  filename = "";
-
-  if(flg & 0x04) {  //FEXTRA
-    unsigned xlen = data[p + 0];
-    xlen |= data[p + 1] << 8;
-    p += 2 + xlen;
-  }
-
-  if(flg & 0x08) {  //FNAME
-    char buffer[PATH_MAX];
-    for(unsigned n = 0; n < PATH_MAX; n++, p++) {
-      buffer[n] = data[p];
-      if(data[p] == 0) break;
-    }
-    if(data[p++]) return false;
-    filename = buffer;
-  }
-
-  if(flg & 0x10) {  //FCOMMENT
-    while(data[p++]);
-  }
-
-  if(flg & 0x02) {  //FHCRC
-    p += 2;
-  }
-
-  this->size = isize;
-  this->data = new uint8_t[this->size];
-  return inflate(this->data, this->size, data + p, size - p - 8);
-}
-
-gzip::gzip() : data(0) {
-}
-
-gzip::~gzip() {
-  if(data) delete[] data;
-}
-
-}
-
-#endif

bsnes/nall/http.hpp

@@ -1,176 +0,0 @@
-#ifndef NALL_HTTP_HPP
-#define NALL_HTTP_HPP
-
-#if !defined(_WIN32)
-  #include <sys/types.h>
-  #include <sys/socket.h>
-  #include <netinet/in.h>
-  #include <netdb.h>
-#else
-  #include <windows.h>
-  #include <winsock2.h>
-  #include <ws2tcpip.h>
-#endif
-
-#include <nall/platform.hpp>
-#include <nall/string.hpp>
-
-namespace nall {
-
-struct http {
-  string hostname;
-  addrinfo *serverinfo;
-  int serversocket;
-  string header;
-
-  inline void download(const string &path, uint8_t *&data, unsigned &size) {
-    data = 0;
-    size = 0;
-
-    send({
-      "GET ", path, " HTTP/1.1\r\n"
-      "Host: ", hostname, "\r\n"
-      "Connection: close\r\n"
-      "\r\n"
-    });
-
-    header = downloadHeader();
-    downloadContent(data, size);
-  }
-
-  inline bool connect(string host, unsigned port) {
-    hostname = host;
-
-    addrinfo hints;
-    memset(&hints, 0, sizeof(addrinfo));
-    hints.ai_family = AF_UNSPEC;
-    hints.ai_socktype = SOCK_STREAM;
-    hints.ai_flags = AI_PASSIVE;
-
-    int status = getaddrinfo(hostname, string(port), &hints, &serverinfo);
-    if(status != 0) return false;
-
-    serversocket = socket(serverinfo->ai_family, serverinfo->ai_socktype, serverinfo->ai_protocol);
-    if(serversocket == -1) return false;
-
-    int result = ::connect(serversocket, serverinfo->ai_addr, serverinfo->ai_addrlen);
-    if(result == -1) return false;
-
-    return true;
-  }
-
-  inline bool send(const string &data) {
-    return send((const uint8_t*)(const char*)data, data.length());
-  }
-
-  inline bool send(const uint8_t *data, unsigned size) {
-    while(size) {
-      int length = ::send(serversocket, (const char*)data, size, 0);
-      if(length == -1) return false;
-      data += length;
-      size -= length;
-    }
-    return true;
-  }
-
-  inline string downloadHeader() {
-    string output;
-    do {
-      char buffer[2];
-      int length = recv(serversocket, buffer, 1, 0);
-      if(length <= 0) return output;
-      buffer[1] = 0;
-      output.append(buffer);
-    } while(output.endswith("\r\n\r\n") == false);
-    return output;
-  }
-
-  inline string downloadChunkLength() {
-    string output;
-    do {
-      char buffer[2];
-      int length = recv(serversocket, buffer, 1, 0);
-      if(length <= 0) return output;
-      buffer[1] = 0;
-      output.append(buffer);
-    } while(output.endswith("\r\n") == false);
-    return output;
-  }
-
-  inline void downloadContent(uint8_t *&data, unsigned &size) {
-    unsigned capacity = 0;
-
-    if(header.iposition("\r\nTransfer-Encoding: chunked\r\n")) {
-      while(true) {
-        unsigned length = hex(downloadChunkLength());
-        if(length == 0) break;
-        capacity += length;
-        data = (uint8_t*)realloc(data, capacity);
-
-        char buffer[length];
-        while(length) {
-          int packetlength = recv(serversocket, buffer, length, 0);
-          if(packetlength <= 0) break;
-          memcpy(data + size, buffer, packetlength);
-          size += packetlength;
-          length -= packetlength;
-        }
-      }
-    } else if(auto position = header.iposition("\r\nContent-Length: ")) {
-      unsigned length = decimal((const char*)header + position() + 16);
-      while(length) {
-        char buffer[256];
-        int packetlength = recv(serversocket, buffer, min(256, length), 0);
-        if(packetlength <= 0) break;
-        capacity += packetlength;
-        data = (uint8_t*)realloc(data, capacity);
-        memcpy(data + size, buffer, packetlength);
-        size += packetlength;
-        length -= packetlength;
-      }
-    } else {
-      while(true) {
-        char buffer[256];
-        int packetlength = recv(serversocket, buffer, 256, 0);
-        if(packetlength <= 0) break;
-        capacity += packetlength;
-        data = (uint8_t*)realloc(data, capacity);
-        memcpy(data + size, buffer, packetlength);
-        size += packetlength;
-      }
-    }
-
-    data = (uint8_t*)realloc(data, capacity + 1);
-    data[capacity] = 0;
-  }
-
-  inline void disconnect() {
-    close(serversocket);
-    freeaddrinfo(serverinfo);
-    serverinfo = 0;
-    serversocket = -1;
-  }
-
-  #ifdef _WIN32
-  inline int close(int sock) {
-    return closesocket(sock);
-  }
-
-  inline http() {
-    int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    if(sock == INVALID_SOCKET && WSAGetLastError() == WSANOTINITIALISED) {
-      WSADATA wsaData;
-      if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
-        WSACleanup();
-        return;
-      }
-    } else {
-      close(sock);
-    }
-  }
-  #endif
-};
-
-}
-
-#endif

bsnes/nall/inflate.hpp

@@ -1,358 +0,0 @@
-#ifndef NALL_INFLATE_HPP
-#define NALL_INFLATE_HPP
-
-#include <setjmp.h>
-
-namespace nall {
-
-namespace puff {
-  inline int puff(
-    unsigned char *dest, unsigned long *destlen,
-    unsigned char *source, unsigned long *sourcelen
-  );
-}
-
-inline bool inflate(
-  uint8_t *target, unsigned targetLength,
-  const uint8_t *source, unsigned sourceLength
-) {
-  unsigned long tl = targetLength, sl = sourceLength;
-  int result = puff::puff((unsigned char*)target, &tl, (unsigned char*)source, &sl);
-  return result == 0;
-}
-
-namespace puff {
-
-//zlib/contrib/puff.c
-//version 2.1*
-//author: Mark Adler
-//license: zlib
-//ported by: byuu
-
-//* I have corrected a bug in fixed(), where it was accessing uninitialized
-//  memory: calling construct() with lencode prior to initializing lencode.count
-
-enum {
-  MAXBITS   =  15,
-  MAXLCODES = 286,
-  MAXDCODES =  30,
-  FIXLCODES = 288,
-  MAXCODES  = MAXLCODES + MAXDCODES,
-};
-
-struct state {
-  unsigned char *out;
-  unsigned long outlen;
-  unsigned long outcnt;
-
-  unsigned char *in;
-  unsigned long inlen;
-  unsigned long incnt;
-  int bitbuf;
-  int bitcnt;
-
-  jmp_buf env;
-};
-
-struct huffman {
-  short *count;
-  short *symbol;
-};
-
-inline int bits(state *s, int need) {
-  long val;
-
-  val = s->bitbuf;
-  while(s->bitcnt < need) {
-    if(s->incnt == s->inlen) longjmp(s->env, 1);
-    val |= (long)(s->in[s->incnt++]) << s->bitcnt;
-    s->bitcnt += 8;
-  }
-
-  s->bitbuf = (int)(val >> need);
-  s->bitcnt -= need;
-
-  return (int)(val & ((1L << need) - 1));
-}
-
-inline int stored(state *s) {
-  unsigned len;
-
-  s->bitbuf = 0;
-  s->bitcnt = 0;
-
-  if(s->incnt + 4 > s->inlen) return 2;
-  len  = s->in[s->incnt++];
-  len |= s->in[s->incnt++] << 8;
-  if(s->in[s->incnt++] != (~len & 0xff) ||
-     s->in[s->incnt++] != ((~len >> 8) & 0xff)
-  ) return 2;
-
-  if(s->incnt + len > s->inlen) return 2;
-  if(s->out != 0) {
-    if(s->outcnt + len > s->outlen) return 1;
-    while(len--) s->out[s->outcnt++] = s->in[s->incnt++];
-  } else {
-    s->outcnt += len;
-    s->incnt += len;
-  }
-
-  return 0;
-}
-
-inline int decode(state *s, huffman *h) {
-  int len, code, first, count, index, bitbuf, left;
-  short *next;
-
-  bitbuf = s->bitbuf;
-  left = s->bitcnt;
-  code = first = index = 0;
-  len = 1;
-  next = h->count + 1;
-  while(true) {
-    while(left--) {
-      code |= bitbuf & 1;
-      bitbuf >>= 1;
-      count = *next++;
-      if(code - count < first) {
-        s->bitbuf = bitbuf;
-        s->bitcnt = (s->bitcnt - len) & 7;
-        return h->symbol[index + (code - first)];
-      }
-      index += count;
-      first += count;
-      first <<= 1;
-      code <<= 1;
-      len++;
-    }
-    left = (MAXBITS + 1) - len;
-    if(left == 0) break;
-    if(s->incnt == s->inlen) longjmp(s->env, 1);
-    bitbuf = s->in[s->incnt++];
-    if(left > 8) left = 8;
-  }
-
-  return -10;
-}
-
-inline int construct(huffman *h, short *length, int n) {
-  int symbol, len, left;
-  short offs[MAXBITS + 1];
-
-  for(len = 0; len <= MAXBITS; len++) h->count[len] = 0;
-  for(symbol = 0; symbol < n; symbol++) h->count[length[symbol]]++;
-  if(h->count[0] == n) return 0;
-
-  left = 1;
-  for(len = 1; len <= MAXBITS; len++) {
-    left <<= 1;
-    left -= h->count[len];
-    if(left < 0) return left;
-  }
-
-  offs[1] = 0;
-  for(len = 1; len < MAXBITS; len++) offs[len + 1] = offs[len] + h->count[len];
-
-  for(symbol = 0; symbol < n; symbol++) {
-    if(length[symbol] != 0) h->symbol[offs[length[symbol]]++] = symbol;
-  }
-
-  return left;
-}
-
-inline int codes(state *s, huffman *lencode, huffman *distcode) {
-  int symbol, len;
-  unsigned dist;
-  static const short lens[29] = {
-    3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
-    35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258
-  };
-  static const short lext[29] = {
-    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
-    3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
-  };
-  static const short dists[30] = {
-    1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
-    257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
-    8193, 12289, 16385, 24577
-  };
-  static const short dext[30] = {
-    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
-    7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
-    12, 12, 13, 13
-  };
-
-  do {
-    symbol = decode(s, lencode);
-    if(symbol < 0) return symbol;
-    if(symbol < 256) {
-      if(s->out != 0) {
-        if(s->outcnt == s->outlen) return 1;
-        s->out[s->outcnt] = symbol;
-      }
-      s->outcnt++;
-    } else if(symbol > 256) {
-      symbol -= 257;
-      if(symbol >= 29) return -10;
-      len = lens[symbol] + bits(s, lext[symbol]);
-
-      symbol = decode(s, distcode);
-      if(symbol < 0) return symbol;
-      dist = dists[symbol] + bits(s, dext[symbol]);
-#ifndef INFLATE_ALLOW_INVALID_DISTANCE_TOO_FAR
-      if(dist > s->outcnt) return -11;
-#endif
-
-      if(s->out != 0) {
-        if(s->outcnt + len > s->outlen) return 1;
-        while(len--) {
-          s->out[s->outcnt] =
-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOO_FAR
-          dist > s->outcnt ? 0 :
-#endif
-          s->out[s->outcnt - dist];
-          s->outcnt++;
-        }
-      } else {
-        s->outcnt += len;
-      }
-    }
-  } while(symbol != 256);
-
-  return 0;
-}
-
-inline int fixed(state *s) {
-  static int virgin = 1;
-  static short lencnt[MAXBITS + 1], lensym[FIXLCODES];
-  static short distcnt[MAXBITS + 1], distsym[MAXDCODES];
-  static huffman lencode, distcode;
-
-  if(virgin) {
-    int symbol = 0;
-    short lengths[FIXLCODES];
-
-    lencode.count = lencnt;
-    lencode.symbol = lensym;
-    distcode.count = distcnt;
-    distcode.symbol = distsym;
-
-    for(; symbol <       144; symbol++) lengths[symbol] = 8;
-    for(; symbol <       256; symbol++) lengths[symbol] = 9;
-    for(; symbol <       280; symbol++) lengths[symbol] = 7;
-    for(; symbol < FIXLCODES; symbol++) lengths[symbol] = 8;
-    construct(&lencode, lengths, FIXLCODES);
-
-    for(symbol = 0; symbol < MAXDCODES; symbol++) lengths[symbol] = 5;
-    construct(&distcode, lengths, MAXDCODES);
-
-    virgin = 0;
-  }
-
-  return codes(s, &lencode, &distcode);
-}
-
-inline int dynamic(state *s) {
-  int nlen, ndist, ncode, index, err;
-  short lengths[MAXCODES];
-  short lencnt[MAXBITS + 1], lensym[MAXLCODES];
-  short distcnt[MAXBITS + 1], distsym[MAXDCODES];
-  huffman lencode, distcode;
-  static const short order[19] = {
-    16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
-  };
-
-  lencode.count = lencnt;
-  lencode.symbol = lensym;
-  distcode.count = distcnt;
-  distcode.symbol = distsym;
-
-  nlen = bits(s, 5) + 257;
-  ndist = bits(s, 5) + 1;
-  ncode = bits(s, 4) + 4;
-  if(nlen > MAXLCODES || ndist > MAXDCODES) return -3;
-
-  for(index = 0; index < ncode; index++) lengths[order[index]] = bits(s, 3);
-  for(; index < 19; index++) lengths[order[index]] = 0;
-
-  err = construct(&lencode, lengths, 19);
-  if(err != 0) return -4;
-
-  index = 0;
-  while(index < nlen + ndist) {
-    int symbol, len;
-
-    symbol = decode(s, &lencode);
-    if(symbol < 16) {
-      lengths[index++] = symbol;
-    } else {
-      len = 0;
-      if(symbol == 16) {
-        if(index == 0) return -5;
-        len = lengths[index - 1];
-        symbol = 3 + bits(s, 2);
-      } else if(symbol == 17) {
-        symbol = 3 + bits(s, 3);
-      } else {
-        symbol = 11 + bits(s, 7);
-      }
-      if(index + symbol > nlen + ndist) return -6;
-      while(symbol--) lengths[index++] = len;
-    }
-  }
-
-  if(lengths[256] == 0) return -9;
-
-  err = construct(&lencode, lengths, nlen);
-  if(err < 0 || (err > 0 && nlen - lencode.count[0] != 1)) return -7;
-
-  err = construct(&distcode, lengths + nlen, ndist);
-  if(err < 0 || (err > 0 && ndist - distcode.count[0] != 1)) return -8;
-
-  return codes(s, &lencode, &distcode);
-}
-
-inline int puff(
-  unsigned char *dest, unsigned long *destlen,
-  unsigned char *source, unsigned long *sourcelen
-) {
-  state s;
-  int last, type, err;
-
-  s.out = dest;
-  s.outlen = *destlen;
-  s.outcnt = 0;
-
-  s.in = source;
-  s.inlen = *sourcelen;
-  s.incnt = 0;
-  s.bitbuf = 0;
-  s.bitcnt = 0;
-
-  if(setjmp(s.env) != 0) {
-    err = 2;
-  } else {
-    do {
-      last = bits(&s, 1);
-      type = bits(&s, 2);
-      err = type == 0 ? stored(&s)
-          : type == 1 ? fixed(&s)
-          : type == 2 ? dynamic(&s)
-          : -1;
-      if(err != 0) break;
-    } while(!last);
-  }
-
-  if(err <= 0) {
-    *destlen = s.outcnt;
-    *sourcelen = s.incnt;
-  }
-
-  return err;
-}
-
-}
-
-}
-
-#endif

bsnes/nall/ips.hpp

@@ -1,110 +0,0 @@
-#ifndef NALL_IPS_HPP
-#define NALL_IPS_HPP
-
-#include <nall/file.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-
-namespace nall {
-
-struct ips {
-  inline bool apply();
-  inline void source(const uint8_t *data, unsigned size);
-  inline void modify(const uint8_t *data, unsigned size);
-  inline bool source(const string &filename);
-  inline bool modify(const string &filename);
-  inline ips();
-  inline ~ips();
-
-  uint8_t *data;
-  unsigned size;
-  const uint8_t *sourceData;
-  unsigned sourceSize;
-  const uint8_t *modifyData;
-  unsigned modifySize;
-};
-
-bool ips::apply() {
-  if(modifySize < 8) return false;
-  if(modifyData[0] != 'P') return false;
-  if(modifyData[1] != 'A') return false;
-  if(modifyData[2] != 'T') return false;
-  if(modifyData[3] != 'C') return false;
-  if(modifyData[4] != 'H') return false;
-
-  if(data) delete[] data;
-  data = new uint8_t[16 * 1024 * 1024 + 65536]();  //maximum size of IPS patch + single-tag padding
-  size = sourceSize;
-  memcpy(data, sourceData, sourceSize);
-  unsigned offset = 5;
-
-  while(true) {
-    unsigned address, length;
-
-    if(offset > modifySize - 3) break;
-    address  = modifyData[offset++] << 16;
-    address |= modifyData[offset++] <<  8;
-    address |= modifyData[offset++] <<  0;
-
-    if(address == 0x454f46) {  //EOF
-      if(offset == modifySize) return true;
-      if(offset == modifySize - 3) {
-        size  = modifyData[offset++] << 16;
-        size |= modifyData[offset++] <<  8;
-        size |= modifyData[offset++] <<  0;
-        return true;
-      }
-    }
-
-    if(offset > modifySize - 2) break;
-    length  = modifyData[offset++] << 8;
-    length |= modifyData[offset++] << 0;
-
-    if(length) {  //Copy
-      if(offset > modifySize - length) break;
-      while(length--) data[address++] = modifyData[offset++];
-    } else {  //RLE
-      if(offset > modifySize - 3) break;
-      length  = modifyData[offset++] << 8;
-      length |= modifyData[offset++] << 0;
-      if(length == 0) break;  //illegal
-      while(length--) data[address++] = modifyData[offset];
-      offset++;
-    }
-
-    size = max(size, address);
-  }
-
-  delete[] data;
-  data = 0;
-  return false;
-}
-
-void ips::source(const uint8_t *data, unsigned size) {
-  sourceData = data, sourceSize = size;
-}
-
-void ips::modify(const uint8_t *data, unsigned size) {
-  modifyData = data, modifySize = size;
-}
-
-bool ips::source(const string &filename) {
-  return file::read(filename, sourceData, sourceSize);
-}
-
-bool ips::modify(const string &filename) {
-  return file::read(filename, modifyData, modifySize);
-}
-
-ips::ips() : data(0), sourceData(0), modifyData(0) {
-}
-
-ips::~ips() {
-  if(data) delete[] data;
-  if(sourceData) delete[] sourceData;
-  if(modifyData) delete[] modifyData;
-}
-
-}
-
-#endif

bsnes/nall/lzss.hpp

@@ -1,165 +0,0 @@
-#ifndef NALL_LZSS_HPP
-#define NALL_LZSS_HPP
-
-#include <nall/file.hpp>
-#include <nall/filemap.hpp>
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-
-namespace nall {
-
-//19:5 pulldown
-//8:1 marker: d7-d0
-//length: { 4 - 35 }, offset: { 1 - 0x80000 }
-//4-byte file size header
-//little-endian encoding
-struct lzss {
-  inline void source(const uint8_t *data, unsigned size);
-  inline bool source(const string &filename);
-  inline unsigned size() const;
-  inline bool compress(const string &filename);
-  inline bool decompress(uint8_t *targetData, unsigned targetSize);
-  inline bool decompress(const string &filename);
-
-protected:
-  struct Node {
-    unsigned offset;
-    Node *next;
-    inline Node() : offset(0), next(0) {}
-    inline ~Node() { if(next) delete next; }
-  } *tree[65536];
-
-  filemap sourceFile;
-  const uint8_t *sourceData;
-  unsigned sourceSize;
-
-public:
-  inline lzss() : sourceData(0), sourceSize(0) {}
-};
-
-void lzss::source(const uint8_t *data, unsigned size) {
-  sourceData = data;
-  sourceSize = size;
-}
-
-bool lzss::source(const string &filename) {
-  if(sourceFile.open(filename, filemap::mode::read) == false) return false;
-  sourceData = sourceFile.data();
-  sourceSize = sourceFile.size();
-  return true;
-}
-
-unsigned lzss::size() const {
-  unsigned size = 0;
-  if(sourceSize < 4) return size;
-  for(unsigned n = 0; n < 32; n += 8) size |= sourceData[n >> 3] << n;
-  return size;
-}
-
-bool lzss::compress(const string &filename) {
-  file targetFile;
-  if(targetFile.open(filename, file::mode::write) == false) return false;
-
-  for(unsigned n = 0; n < 32; n += 8) targetFile.write(sourceSize >> n);
-  for(unsigned n = 0; n < 65536; n++) tree[n] = 0;
-
-  uint8_t buffer[25];
-  unsigned sourceOffset = 0;
-
-  while(sourceOffset < sourceSize) {
-    uint8_t mask = 0x00;
-    unsigned bufferOffset = 1;
-
-    for(unsigned iteration = 0; iteration < 8; iteration++) {
-      if(sourceOffset >= sourceSize) break;
-
-      uint16_t symbol = sourceData[sourceOffset + 0];
-      if(sourceOffset < sourceSize - 1) symbol |= sourceData[sourceOffset + 1] << 8;
-      Node *node = tree[symbol];
-      unsigned maxLength = 0, maxOffset = 0;
-
-      while(node) {
-        if(node->offset < sourceOffset - 0x80000) {
-          //out-of-range: all subsequent nodes will also be, so free up their memory
-          if(node->next) { delete node->next; node->next = 0; }
-          break;
-        }
-
-        unsigned length = 0, x = sourceOffset, y = node->offset;
-        while(length < 35 && x < sourceSize && sourceData[x++] == sourceData[y++]) length++;
-        if(length > maxLength) maxLength = length, maxOffset = node->offset;
-        if(length == 35) break;
-
-        node = node->next;
-      }
-
-      //attach current symbol to top of tree for subsequent searches
-      node = new Node;
-      node->offset = sourceOffset;
-      node->next = tree[symbol];
-      tree[symbol] = node;
-
-      if(maxLength < 4) {
-        buffer[bufferOffset++] = sourceData[sourceOffset++];
-      } else {
-        unsigned output = ((maxLength - 4) << 19) | (sourceOffset - 1 - maxOffset);
-        for(unsigned n = 0; n < 24; n += 8) buffer[bufferOffset++] = output >> n;
-        mask |= 0x80 >> iteration;
-        sourceOffset += maxLength;
-      }
-    }
-
-    buffer[0] = mask;
-    targetFile.write(buffer, bufferOffset);
-  }
-
-  sourceFile.close();
-  targetFile.close();
-  return true;
-}
-
-bool lzss::decompress(uint8_t *targetData, unsigned targetSize) {
-  if(targetSize < size()) return false;
-
-  unsigned sourceOffset = 4, targetOffset = 0;
-  while(sourceOffset < sourceSize) {
-    uint8_t mask = sourceData[sourceOffset++];
-
-    for(unsigned iteration = 0; iteration < 8; iteration++) {
-      if(sourceOffset >= sourceSize) break;
-
-      if((mask & (0x80 >> iteration)) == 0) {
-        targetData[targetOffset++] = sourceData[sourceOffset++];
-      } else {
-        unsigned code = 0;
-        for(unsigned n = 0; n < 24; n += 8) code |= sourceData[sourceOffset++] << n;
-        unsigned length = (code >> 19) + 4;
-        unsigned offset = targetOffset - 1 - (code & 0x7ffff);
-        while(length--) targetData[targetOffset++] = targetData[offset++];
-      }
-    }
-  }
-}
-
-bool lzss::decompress(const string &filename) {
-  if(sourceSize < 4) return false;
-  unsigned targetSize = size();
-
-  file fp;
-  if(fp.open(filename, file::mode::write) == false) return false;
-  fp.truncate(targetSize);
-  fp.close();
-
-  filemap targetFile;
-  if(targetFile.open(filename, filemap::mode::readwrite) == false) return false;
-  uint8_t *targetData = targetFile.data();
-
-  bool result = decompress(targetData, targetSize);
-  sourceFile.close();
-  targetFile.close();
-  return result;
-}
-
-}
-
-#endif

bsnes/nall/moduloarray.hpp

@@ -1,40 +0,0 @@
-#ifndef NALL_MODULO_HPP
-#define NALL_MODULO_HPP
-
-#include <nall/serializer.hpp>
-
-namespace nall {
-  template<typename T, int size> class modulo_array {
-  public:
-    inline T operator[](int index) const {
-      return buffer[size + index];
-    }
-
-    inline T read(int index) const {
-      return buffer[size + index];
-    }
-
-    inline void write(unsigned index, const T value) {
-      buffer[index] =
-      buffer[index + size] =
-      buffer[index + size + size] = value;
-    }
-
-    void serialize(serializer &s) {
-      s.array(buffer, size * 3);
-    }
-
-    modulo_array() {
-      buffer = new T[size * 3]();
-    }
-
-    ~modulo_array() {
-      delete[] buffer;
-    }
-
-  private:
-    T *buffer;
-  };
-}
-
-#endif

bsnes/nall/platform.hpp

@@ -1,133 +0,0 @@
-#ifndef NALL_PLATFORM_HPP
-#define NALL_PLATFORM_HPP
-
-#if defined(_WIN32)
-  //minimum version needed for _wstat64, etc
-  #undef  __MSVCRT_VERSION__
-  #define __MSVCRT_VERSION__ 0x0601
-  #include <nall/windows/utf8.hpp>
-#endif
-
-//=========================
-//standard platform headers
-//=========================
-
-#include <limits>
-
-#include <assert.h>
-#include <limits.h>
-#include <math.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#if defined(_WIN32)
-  #include <io.h>
-  #include <direct.h>
-  #include <shlobj.h>
-  #include <wchar.h>
-  #undef interface
-  #define dllexport __declspec(dllexport)
-#else
-  #include <unistd.h>
-  #include <pwd.h>
-  #define dllexport
-#endif
-
-//==================
-//warning supression
-//==================
-
-//Visual C++
-#if defined(_MSC_VER)
-  //disable libc "deprecation" warnings
-  #pragma warning(disable:4996)
-#endif
-
-//================
-//POSIX compliance
-//================
-
-#if defined(_MSC_VER)
-  #define PATH_MAX  _MAX_PATH
-  #define va_copy(dest, src)  ((dest) = (src))
-#endif
-
-#if defined(_WIN32)
-  #define getcwd      _getcwd
-  #define ftruncate   _chsize
-  #define mkdir(n, m) _wmkdir(nall::utf16_t(n))
-  #define putenv      _putenv
-  #define rmdir       _rmdir
-  #define usleep(n)   Sleep(n / 1000)
-  #define vsnprintf   _vsnprintf
-#endif
-
-//================
-//inline expansion
-//================
-
-#if defined(__GNUC__)
-  #define noinline      __attribute__((noinline))
-  #define inline        inline
-  #define alwaysinline  inline __attribute__((always_inline))
-#elif defined(_MSC_VER)
-  #define noinline      __declspec(noinline)
-  #define inline        inline
-  #define alwaysinline  inline __forceinline
-#else
-  #define noinline
-  #define inline        inline
-  #define alwaysinline  inline
-#endif
-
-//=========================
-//file system functionality
-//=========================
-
-#if defined(_WIN32)
-  inline char* realpath(const char *filename, char *resolvedname) {
-    wchar_t fn[_MAX_PATH] = L"";
-    _wfullpath(fn, nall::utf16_t(filename), _MAX_PATH);
-    strcpy(resolvedname, nall::utf8_t(fn));
-    for(unsigned n = 0; resolvedname[n]; n++) if(resolvedname[n] == '\\') resolvedname[n] = '/';
-    return resolvedname;
-  }
-
-  inline char* userpath(char *path) {
-    wchar_t fp[_MAX_PATH] = L"";
-    SHGetFolderPathW(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, 0, 0, fp);
-    strcpy(path, nall::utf8_t(fp));
-    for(unsigned n = 0; path[n]; n++) if(path[n] == '\\') path[n] = '/';
-    return path;
-  }
-
-  inline char* getcwd(char *path) {
-    wchar_t fp[_MAX_PATH] = L"";
-    _wgetcwd(fp, _MAX_PATH);
-    strcpy(path, nall::utf8_t(fp));
-    for(unsigned n = 0; path[n]; n++) if(path[n] == '\\') path[n] = '/';
-    return path;
-  }
-#else
-  //realpath() already exists
-
-  inline char* userpath(char *path) {
-    *path = 0;
-    struct passwd *userinfo = getpwuid(getuid());
-    if(userinfo) strcpy(path, userinfo->pw_dir);
-    return path;
-  }
-
-  inline char *getcwd(char *path) {
-    return getcwd(path, PATH_MAX);
-  }
-#endif
-
-#endif
-

bsnes/nall/priorityqueue.hpp

@@ -1,109 +0,0 @@
-#ifndef NALL_PRIORITYQUEUE_HPP
-#define NALL_PRIORITYQUEUE_HPP
-
-#include <limits>
-#include <nall/function.hpp>
-#include <nall/serializer.hpp>
-#include <nall/utility.hpp>
-
-namespace nall {
-  template<typename type_t> void priority_queue_nocallback(type_t) {}
-
-  //priority queue implementation using binary min-heap array;
-  //does not require normalize() function.
-  //O(1)     find   (tick)
-  //O(log n) insert (enqueue)
-  //O(log n) remove (dequeue)
-  template<typename type_t> class priority_queue {
-  public:
-    inline void tick(unsigned ticks) {
-      basecounter += ticks;
-      while(heapsize && gte(basecounter, heap[0].counter)) callback(dequeue());
-    }
-
-    //counter is relative to current time (eg enqueue(64, ...) fires in 64 ticks);
-    //counter cannot exceed std::numeric_limits<unsigned>::max() >> 1.
-    void enqueue(unsigned counter, type_t event) {
-      unsigned child = heapsize++;
-      counter += basecounter;
-
-      while(child) {
-        unsigned parent = (child - 1) >> 1;
-        if(gte(counter, heap[parent].counter)) break;
-
-        heap[child].counter = heap[parent].counter;
-        heap[child].event = heap[parent].event;
-        child = parent;
-      }
-
-      heap[child].counter = counter;
-      heap[child].event = event;
-    }
-
-    type_t dequeue() {
-      type_t event(heap[0].event);
-      unsigned parent = 0;
-      unsigned counter = heap[--heapsize].counter;
-
-      while(true) {
-        unsigned child = (parent << 1) + 1;
-        if(child >= heapsize) break;
-        if(child + 1 < heapsize && gte(heap[child].counter, heap[child + 1].counter)) child++;
-        if(gte(heap[child].counter, counter)) break;
-
-        heap[parent].counter = heap[child].counter;
-        heap[parent].event = heap[child].event;
-        parent = child;
-      }
-
-      heap[parent].counter = counter;
-      heap[parent].event = heap[heapsize].event;
-      return event;
-    }
-
-    void reset() {
-      basecounter = 0;
-      heapsize = 0;
-    }
-
-    void serialize(serializer &s) {
-      s.integer(basecounter);
-      s.integer(heapsize);
-      for(unsigned n = 0; n < heapcapacity; n++) {
-        s.integer(heap[n].counter);
-        s.integer(heap[n].event);
-      }
-    }
-
-    priority_queue(unsigned size, function<void (type_t)> callback_ = &priority_queue_nocallback<type_t>)
-    : callback(callback_) {
-      heap = new heap_t[size];
-      heapcapacity = size;
-      reset();
-    }
-
-    ~priority_queue() {
-      delete[] heap;
-    }
-
-    priority_queue& operator=(const priority_queue&) = delete;
-    priority_queue(const priority_queue&) = delete;
-
-  private:
-    function<void (type_t)> callback;
-    unsigned basecounter;
-    unsigned heapsize;
-    unsigned heapcapacity;
-    struct heap_t {
-      unsigned counter;
-      type_t event;
-    } *heap;
-
-    //return true if x is greater than or equal to y
-    inline bool gte(unsigned x, unsigned y) {
-      return x - y < (std::numeric_limits<unsigned>::max() >> 1);
-    }
-  };
-}
-
-#endif

bsnes/nall/property.hpp

@@ -1,91 +0,0 @@
-#ifndef NALL_PROPERTY_HPP
-#define NALL_PROPERTY_HPP
-
-//nall::property implements ownership semantics into container classes
-//example: property<owner>::readonly<type> implies that only owner has full
-//access to type; and all other code has readonly access.
-//
-//this code relies on extended friend semantics from C++0x to work, as it
-//declares a friend class via a template paramter. it also exploits a bug in
-//G++ 4.x to work even in C++98 mode.
-//
-//if compiling elsewhere, simply remove the friend class and private semantics
-
-//property can be used either of two ways:
-//struct foo {
-//  property<foo>::readonly<bool> x;
-//  property<foo>::readwrite<int> y;
-//};
-//-or-
-//struct foo : property<foo> {
-//  readonly<bool> x;
-//  readwrite<int> y;
-//};
-
-//return types are const T& (byref) instead fo T (byval) to avoid major speed
-//penalties for objects with expensive copy constructors
-
-//operator-> provides access to underlying object type:
-//readonly<Object> foo;
-//foo->bar();
-//... will call Object::bar();
-
-//operator='s reference is constant so as to avoid leaking a reference handle
-//that could bypass access restrictions
-
-//both constant and non-constant operators are provided, though it may be
-//necessary to cast first, for instance:
-//struct foo : property<foo> { readonly<int> bar; } object;
-//int main() { int value = const_cast<const foo&>(object); }
-
-//writeonly is useful for objects that have non-const reads, but const writes.
-//however, to avoid leaking handles, the interface is very restricted. the only
-//way to write is via operator=, which requires conversion via eg copy
-//constructor. example:
-//struct foo {
-//  foo(bool value) { ... }
-//};
-//writeonly<foo> bar;
-//bar = true;
-
-namespace nall {
-  template<typename C> struct property {
-    template<typename T> struct traits { typedef T type; };
-
-    template<typename T> struct readonly {
-      const T* operator->() const { return &value; }
-      const T& operator()() const { return value; }
-      operator const T&() const { return value; }
-    private:
-      T* operator->() { return &value; }
-      operator T&() { return value; }
-      const T& operator=(const T& value_) { return value = value_; }
-      T value;
-      friend class traits<C>::type;
-    };
-
-    template<typename T> struct writeonly {
-      void operator=(const T& value_) { value = value_; }
-    private:
-      const T* operator->() const { return &value; }
-      const T& operator()() const { return value; }
-      operator const T&() const { return value; }
-      T* operator->() { return &value; }
-      operator T&() { return value; }
-      T value;
-      friend class traits<C>::type;
-    };
-
-    template<typename T> struct readwrite {
-      const T* operator->() const { return &value; }
-      const T& operator()() const { return value; }
-      operator const T&() const { return value; }
-      T* operator->() { return &value; }
-      operator T&() { return value; }
-      const T& operator=(const T& value_) { return value = value_; }
-      T value;
-    };
-  };
-}
-
-#endif

bsnes/nall/public_cast.hpp

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

bsnes/nall/random.hpp

@@ -1,28 +0,0 @@
-#ifndef NALL_RANDOM_HPP
-#define NALL_RANDOM_HPP
-
-namespace nall {
-  //pseudo-random number generator
-  inline unsigned prng() {
-    static unsigned n = 0;
-    return n = (n >> 1) ^ (((n & 1) - 1) & 0xedb88320);
-  }
-
-  struct random_lfsr {
-    inline void seed(unsigned seed__) {
-      seed_ = seed__;
-    }
-
-    inline unsigned operator()() {
-      return seed_ = (seed_ >> 1) ^ (((seed_ & 1) - 1) & 0xedb88320);
-    }
-
-    random_lfsr() : seed_(0) {
-    }
-
-  private:
-    unsigned seed_;
-  };
-}
-
-#endif