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

@@ -0,0 +1,120 @@
+#ifndef NALL_EMULATION_GAME_BOY_HPP
+#define NALL_EMULATION_GAME_BOY_HPP
+
+#include <nall/sha256.hpp>
+#include <nall/string.hpp>
+
+namespace nall {
+
+struct GameBoyCartridge {
+  string markup;
+  inline GameBoyCartridge(uint8_t *data, unsigned size);
+
+//private:
+  struct Information {
+    string mapper;
+    bool ram;
+    bool battery;
+    bool rtc;
+    bool rumble;
+
+    unsigned romsize;
+    unsigned ramsize;
+
+    bool cgb;
+    bool cgbonly;
+  } info;
+};
+
+GameBoyCartridge::GameBoyCartridge(uint8_t *romdata, unsigned romsize) {
+  markup = "";
+  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);
+  }
+
+  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;
+    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
+
+  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");
+}
+
+}
+
+#endif

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,93 +0,0 @@
-include nall/Makefile
-snes := snes
-profile := compatibility
-ui := ui-qt
-
-# compiler
-c       := $(compiler) -std=gnu99
-cpp     := $(subst cc,++,$(compiler)) -std=gnu++0x
-flags   := -O3 -fomit-frame-pointer -I. -I$(snes)
-link    :=
-objects :=
-
-# profile-guided instrumentation
-# flags += -fprofile-generate
-# link += -lgcov
-
-# profile-guided optimization
-# flags += -fprofile-use
-
-# 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;
-
-include $(snes)/Makefile
-include $(ui)/Makefile
-
-objects := $(patsubst %,obj/%.o,$(objects))
-
-# targets
-build: ui_build $(objects)
-ifeq ($(platform),osx)
-	test -d ../bsnes.app || mkdir -p ../bsnes.app/Contents/MacOS
-	$(strip $(cpp) -o ../bsnes.app/Contents/MacOS/bsnes $(objects) $(link))
-else
-	$(strip $(cpp) -o out/bsnes $(objects) $(link))
-endif
-
-install:
-ifeq ($(platform),x)
-	install -D -m 755 out/bsnes $(DESTDIR)$(prefix)/bin/bsnes
-	install -D -m 644 ui-qt/data/bsnes.png $(DESTDIR)$(prefix)/share/pixmaps/bsnes.png
-	install -D -m 644 ui-qt/data/bsnes.desktop $(DESTDIR)$(prefix)/share/applications/bsnes.desktop
-	gconftool-2 --type bool --set /desktop/gnome/interface/menus_have_icons true
-endif
-
-uninstall:
-ifeq ($(platform),x)
-	rm $(DESTDIR)$(prefix)/bin/bsnes
-	rm $(DESTDIR)$(prefix)/share/pixmaps/bsnes.png
-	rm $(DESTDIR)$(prefix)/share/applications/bsnes.desktop
-endif
-
-clean: ui_clean
-	-@$(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 launcher libco nall obj out phoenix ruby snes ui-phoenix ui-qt Makefile cc.bat clean.bat sync.sh
-
-help:;

bsnes/cc.bat

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

bsnes/clean.bat

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

bsnes/launcher/bsnes.Manifest

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

bsnes/launcher/cc.bat

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

bsnes/launcher/cc.sh

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

bsnes/launcher/launcher.cpp

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

bsnes/launcher/resource.rc

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

bsnes/libco/ppc-elf.c

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

bsnes/libco/ppc.s

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

bsnes/libco/ppc64.s

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

bsnes/nall/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.4
-  else
-    compiler := gcc
-  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,141 +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;
-    }
-
-    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];
-    }
-  };
-
-  template<typename T> struct has_size<array<T>> { enum { value = true }; };
-}
-
-#endif

bsnes/nall/base64.hpp

@@ -1,90 +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) {
-      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 };
-    return y + ((x - y) & -(x < y));  //min(x, y);
-  }
-
-  template<int bits> inline unsigned uclip(const unsigned x) {
-    enum { m = (1U << bits) - 1 };
-    return (x & m);
-  }
-
-  template<int bits> inline signed sclamp(const signed x) {
-    enum { b = 1U << (bits - 1), m = (1U << (bits - 1)) - 1 };
-    return (x > m) ? m : (x < -b) ? -b : x;
-  }
-
-  template<int bits> inline signed sclip(const signed x) {
-    enum { b = 1U << (bits - 1), m = (1U << bits) - 1 };
-    return ((x & m) ^ b) - b;
-  }
-
-  namespace bit {
-    //lowest(0b1110) == 0b0010
-    template<typename T> inline T lowest(const T x) {
-      return x & -x;
-    }
-
-    //clear_lowest(0b1110) == 0b1100
-    template<typename T> inline T clear_lowest(const T x) {
-      return x & (x - 1);
-    }
-
-    //set_lowest(0b0101) == 0b0111
-    template<typename T> inline T set_lowest(const T x) {
-      return x | (x + 1);
-    }
-
-    //round up to next highest single bit:
-    //round(15) == 16, round(16) == 16, round(17) == 32
-    inline unsigned round(unsigned x) {
-      if((x & (x - 1)) == 0) return x;
-      while(x & (x - 1)) x &= x - 1;
-      return x << 1;
-    }
-  }
-}
-
-#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 string() << *(bool*)data;
-          case signed_t:   return string() << *(signed*)data;
-          case unsigned_t: return string() << *(unsigned*)data;
-          case double_t:   return string() << *(double*)data;
-          case string_t:   return string() << "\"" << *(string*)data << "\"";
-        }
-        return "???";
-      }
-
-      void set(string s) {
-        switch(type) {
-          case boolean_t:  *(bool*)data = (s == "true");      break;
-          case signed_t:   *(signed*)data = strsigned(s);     break;
-          case unsigned_t: *(unsigned*)data = strunsigned(s); break;
-          case double_t:   *(double*)data = strdouble(s);     break;
-          case string_t:   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 << list[i].name << " = " << list[i].get();
-          if(list[i].desc != "") output << " # " << list[i].desc;
-          output << "\r\n";
-          fp.print(output);
-        }
-
-        fp.close();
-        return true;
-      } else {
-        return false;
-      }
-    }
-  };
-}
-
-#endif

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

@@ -1,75 +0,0 @@
-#ifndef NALL_DICTIONARY_HPP
-#define NALL_DICTIONARY_HPP
-
-#include <nall/array.hpp>
-#include <nall/string.hpp>
-#include <nall/utility.hpp>
-
-namespace nall {
-  class dictionary {
-  public:
-    string operator[](const char *input) {
-      for(unsigned i = 0; i < index_input.size(); i++) {
-        if(index_input[i] == input) return index_output[i];
-      }
-
-      //no match, use input; remove input identifier, if one exists
-      if(strbegin(input, "{{")) {
-        if(auto pos = strpos(input, "}}")) {
-          string temp = substr(input, pos() + 2);
-          return temp;
-        }
-      }
-
-      return input;
-    }
-
-    bool import(const char *filename) {
-      string data;
-      if(data.readfile(filename) == false) return false;
-      data.ltrim_once("\xef\xbb\xbf"); //remove UTF-8 marker, if it exists
-      data.replace("\r", "");
-
-      lstring line;
-      line.split("\n", data);
-      for(unsigned i = 0; i < line.size(); i++) {
-        lstring part;
-        //format: "Input" = "Output"
-        part.qsplit("=", line[i]);
-        if(part.size() != 2) continue;
-
-        //remove whitespace
-        part[0].trim();
-        part[1].trim();
-
-        //remove quotes
-        part[0].trim_once("\"");
-        part[1].trim_once("\"");
-
-        unsigned n = index_input.size();
-        index_input[n]  = part[0];
-        index_output[n] = part[1];
-      }
-
-      return true;
-    }
-
-    void reset() {
-      index_input.reset();
-      index_output.reset();
-    }
-
-    ~dictionary() {
-      reset();
-    }
-
-    dictionary& operator=(const dictionary&) = delete;
-    dictionary(const dictionary&) = delete;
-
-  protected:
-    lstring index_input;
-    lstring index_output;
-  };
-}
-
-#endif

bsnes/nall/directory.hpp

@@ -1,129 +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/utf8.hpp>
-#else
-  #include <dirent.h>
-  #include <stdio.h>
-  #include <sys/types.h>
-#endif
-
-namespace nall {
-
-struct directory {
-  static lstring folders(const char *pathname);
-  static lstring files(const char *pathname);
-  static lstring contents(const char *pathname);
-};
-
-#if defined(_WIN32)
-  inline lstring directory::folders(const char *pathname) {
-    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) {
-          list.append(string(utf8_t(data.cFileName), "/"));
-        }
-      }
-      while(FindNextFile(handle, &data) != false) {
-        if(wcscmp(data.cFileName, L".") && wcscmp(data.cFileName, L"..")) {
-          if(data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-            list.append(string(utf8_t(data.cFileName), "/"));
-          }
-        }
-      }
-      FindClose(handle);
-    }
-    sort(&list[0], list.size());
-    return list;
-  }
-
-  inline lstring directory::files(const char *pathname) {
-    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) {
-        list.append(utf8_t(data.cFileName));
-      }
-      while(FindNextFile(handle, &data) != false) {
-        if((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
-          list.append(utf8_t(data.cFileName));
-        }
-      }
-      FindClose(handle);
-    }
-    sort(&list[0], list.size());
-    return list;
-  }
-
-  inline lstring directory::contents(const char *pathname) {
-    lstring folders = directory::folders(pathname);
-    lstring files = directory::files(pathname);
-    foreach(file, files) folders.append(file);
-    return folders;
-  }
-#else
-  inline lstring directory::folders(const char *pathname) {
-    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) list.append(string(ep->d_name, "/"));
-      }
-      closedir(dp);
-    }
-    sort(&list[0], list.size());
-    return list;
-
-  }
-
-  inline lstring directory::files(const char *pathname) {
-    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) list.append(ep->d_name);
-      }
-      closedir(dp);
-    }
-    sort(&list[0], list.size());
-    return list;
-  }
-
-  inline lstring directory::contents(const char *pathname) {
-    lstring folders = directory::folders(pathname);
-    lstring files = directory::files(pathname);
-    foreach(file, files) folders.append(file);
-    return folders;
-  }
-#endif
-
-}
-
-#endif

bsnes/nall/dl.hpp

@@ -1,96 +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/utf8.hpp>
-#endif
-
-namespace nall {
-  struct library {
-    bool opened() const { return handle; }
-    bool open(const char*, 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 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 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 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/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,261 +0,0 @@
-#ifndef NALL_FILE_HPP
-#define NALL_FILE_HPP
-
-#include <stdio.h>
-#include <string.h>
-
-#if !defined(_WIN32)
-  #include <unistd.h>
-#else
-  #include <io.h>
-#endif
-
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-#include <nall/utf8.hpp>
-#include <nall/utility.hpp>
-
-namespace nall {
-  inline FILE* fopen_utf8(const char *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 FileMode { mode_read, mode_write, mode_readwrite, mode_writeread };
-    enum SeekMode { seek_absolute, seek_relative };
-
-    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, SeekMode mode = seek_absolute) {
-      if(!fp) return;  //file not open
-      buffer_flush();
-
-      uintmax_t req_offset = file_offset;
-      switch(mode) {
-        case seek_absolute: req_offset  = offset; break;
-        case seek_relative: req_offset += offset; break;
-      }
-
-      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 char *fn) {
-      #if !defined(_WIN32)
-      FILE *fp = fopen(fn, "rb");
-      #else
-      FILE *fp = _wfopen(utf16_t(fn), L"rb");
-      #endif
-      if(fp) {
-        fclose(fp);
-        return true;
-      }
-      return false;
-    }
-
-    static unsigned size(const char *fn) {
-      #if !defined(_WIN32)
-      FILE *fp = fopen(fn, "rb");
-      #else
-      FILE *fp = _wfopen(utf16_t(fn), L"rb");
-      #endif
-      unsigned filesize = 0;
-      if(fp) {
-        fseek(fp, 0, SEEK_END);
-        filesize = ftell(fp);
-        fclose(fp);
-      }
-      return filesize;
-    }
-
-    bool open() {
-      return fp;
-    }
-
-    bool open(const char *fn, FileMode mode) {
-      if(fp) return false;
-
-      switch(file_mode = mode) {
-        #if !defined(_WIN32)
-        case mode_read:      fp = fopen(fn, "rb");  break;
-        case mode_write:     fp = fopen(fn, "wb+"); break;  //need read permission for buffering
-        case mode_readwrite: fp = fopen(fn, "rb+"); break;
-        case mode_writeread: fp = fopen(fn, "wb+"); break;
-        #else
-        case mode_read:      fp = _wfopen(utf16_t(fn), L"rb");  break;
-        case mode_write:     fp = _wfopen(utf16_t(fn), L"wb+"); break;
-        case mode_readwrite: fp = _wfopen(utf16_t(fn), L"rb+"); break;
-        case mode_writeread: fp = _wfopen(utf16_t(fn), L"wb+"); break;
-        #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;
-    FileMode 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,190 +0,0 @@
-#ifndef NALL_FILEMAP_HPP
-#define NALL_FILEMAP_HPP
-
-#include <nall/stdint.hpp>
-#include <nall/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 filemode { mode_read, mode_write, mode_readwrite, mode_writeread };
-
-    bool open(const char *filename, filemode mode) { return p_open(filename, mode); }
-    void close() { return p_close(); }
-    unsigned size() const { return p_size; }
-    uint8_t* handle() { return p_handle; }
-    const uint8_t* handle() const { return p_handle; }
-    filemap() : p_size(0), p_handle(0) { p_ctor(); }
-    ~filemap() { p_dtor(); }
-
-  private:
-    unsigned p_size;
-    uint8_t *p_handle;
-
-    #if defined(_WIN32)
-    //=============
-    //MapViewOfFile
-    //=============
-
-    HANDLE p_filehandle, p_maphandle;
-
-    bool p_open(const char *filename, filemode mode) {
-      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 char *filename, filemode mode) {
-      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);
-      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,12 +0,0 @@
-#ifndef NALL_FOREACH_HPP
-#define NALL_FOREACH_HPP
-
-#include <type_traits>
-#include <nall/concept.hpp>
-
-#undef foreach
-#define foreach(iter, object) \
-  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)
-
-#endif

bsnes/nall/function.hpp

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

bsnes/nall/input.hpp

@@ -1,386 +0,0 @@
-#ifndef NALL_INPUT_HPP
-#define NALL_INPUT_HPP
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <nall/stdint.hpp>
-#include <nall/string.hpp>
-
-namespace nall {
-
-struct Keyboard;
-Keyboard& keyboard(unsigned = 0);
-
-static const char KeyboardScancodeName[][64] = {
-  "Escape", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12",
-  "PrintScreen", "ScrollLock", "Pause", "Tilde",
-  "Num1", "Num2", "Num3", "Num4", "Num5", "Num6", "Num7", "Num8", "Num9", "Num0",
-  "Dash", "Equal", "Backspace",
-  "Insert", "Delete", "Home", "End", "PageUp", "PageDown",
-  "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",
-  "LeftBracket", "RightBracket", "Backslash", "Semicolon", "Apostrophe", "Comma", "Period", "Slash",
-  "Keypad1", "Keypad2", "Keypad3", "Keypad4", "Keypad5", "Keypad6", "Keypad7", "Keypad8", "Keypad9", "Keypad0",
-  "Point", "Enter", "Add", "Subtract", "Multiply", "Divide",
-  "NumLock", "CapsLock",
-  "Up", "Down", "Left", "Right",
-  "Tab", "Return", "Spacebar", "Menu",
-  "Shift", "Control", "Alt", "Super",
-};
-
-struct Keyboard {
-  const unsigned ID;
-  enum { Base = 1 };
-  enum { Count = 8, Size = 128 };
-
-  enum Scancode {
-    Escape, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12,
-    PrintScreen, ScrollLock, Pause, Tilde,
-    Num1, Num2, Num3, Num4, Num5, Num6, Num7, Num8, Num9, Num0,
-    Dash, Equal, Backspace,
-    Insert, Delete, Home, End, PageUp, PageDown,
-    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,
-    LeftBracket, RightBracket, Backslash, Semicolon, Apostrophe, Comma, Period, Slash,
-    Keypad1, Keypad2, Keypad3, Keypad4, Keypad5, Keypad6, Keypad7, Keypad8, Keypad9, Keypad0,
-    Point, Enter, Add, Subtract, Multiply, Divide,
-    NumLock, CapsLock,
-    Up, Down, Left, Right,
-    Tab, Return, Spacebar, Menu,
-    Shift, Control, Alt, Super,
-    Limit,
-  };
-
-  static signed numberDecode(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(keyboard(i).belongsTo(scancode)) return i;
-    }
-    return -1;
-  }
-
-  static signed keyDecode(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(keyboard(i).isKey(scancode)) return scancode - keyboard(i).key(Escape);
-    }
-    return -1;
-  }
-
-  static signed modifierDecode(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(keyboard(i).isModifier(scancode)) return scancode - keyboard(i).key(Shift);
-    }
-    return -1;
-  }
-
-  static bool isAnyKey(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(keyboard(i).isKey(scancode)) return true;
-    }
-    return false;
-  }
-
-  static bool isAnyModifier(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(keyboard(i).isModifier(scancode)) return true;
-    }
-    return false;
-  }
-
-  static uint16_t decode(const char *name) {
-    string s(name);
-    if(!strbegin(name, "KB")) return 0;
-    s.ltrim("KB");
-    unsigned id = strunsigned(s);
-    auto pos = strpos(s, "::");
-    if(!pos) return 0;
-    s = substr(s, pos() + 2);
-    for(unsigned i = 0; i < Limit; i++) {
-      if(s == KeyboardScancodeName[i]) return Base + Size * id + i;
-    }
-    return 0;
-  }
-
-  string encode(uint16_t code) const {
-    unsigned index = 0;
-    for(unsigned i = 0; i < Count; i++) {
-      if(code >= Base + Size * i && code < Base + Size * (i + 1)) {
-        index = code - (Base + Size * i);
-        break;
-      }
-    }
-    return string() << "KB" << ID << "::" << KeyboardScancodeName[index];
-  }
-
-  uint16_t operator[](Scancode code) const { return Base + ID * Size + code; }
-  uint16_t key(unsigned id) const { return Base + Size * ID + id; }
-  bool isKey(unsigned id) const { return id >= key(Escape) && id <= key(Menu); }
-  bool isModifier(unsigned id) const { return id >= key(Shift) && id <= key(Super); }
-  bool belongsTo(uint16_t scancode) const { return isKey(scancode) || isModifier(scancode); }
-
-  Keyboard(unsigned ID_) : ID(ID_) {}
-};
-
-inline Keyboard& keyboard(unsigned id) {
-  static Keyboard kb0(0), kb1(1), kb2(2), kb3(3), kb4(4), kb5(5), kb6(6), kb7(7);
-  switch(id) { default:
-    case 0: return kb0; case 1: return kb1; case 2: return kb2; case 3: return kb3;
-    case 4: return kb4; case 5: return kb5; case 6: return kb6; case 7: return kb7;
-  }
-}
-
-static const char MouseScancodeName[][64] = {
-  "Xaxis", "Yaxis", "Zaxis",
-  "Button0", "Button1", "Button2", "Button3", "Button4", "Button5", "Button6", "Button7",
-};
-
-struct Mouse;
-Mouse& mouse(unsigned = 0);
-
-struct Mouse {
-  const unsigned ID;
-  enum { Base = Keyboard::Base + Keyboard::Size * Keyboard::Count };
-  enum { Count = 8, Size = 16 };
-  enum { Axes = 3, Buttons = 8 };
-
-  enum Scancode {
-    Xaxis, Yaxis, Zaxis,
-    Button0, Button1, Button2, Button3, Button4, Button5, Button6, Button7,
-    Limit,
-  };
-
-  static signed numberDecode(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(mouse(i).belongsTo(scancode)) return i;
-    }
-    return -1;
-  }
-
-  static signed axisDecode(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(mouse(i).isAxis(scancode)) return scancode - mouse(i).axis(0);
-    }
-    return -1;
-  }
-
-  static signed buttonDecode(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(mouse(i).isButton(scancode)) return scancode - mouse(i).button(0);
-    }
-    return -1;
-  }
-
-  static bool isAnyAxis(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(mouse(i).isAxis(scancode)) return true;
-    }
-    return false;
-  }
-
-  static bool isAnyButton(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(mouse(i).isButton(scancode)) return true;
-    }
-    return false;
-  }
-
-  static uint16_t decode(const char *name) {
-    string s(name);
-    if(!strbegin(name, "MS")) return 0;
-    s.ltrim("MS");
-    unsigned id = strunsigned(s);
-    auto pos = strpos(s, "::");
-    if(!pos) return 0;
-    s = substr(s, pos() + 2);
-    for(unsigned i = 0; i < Limit; i++) {
-      if(s == MouseScancodeName[i]) return Base + Size * id + i;
-    }
-    return 0;
-  }
-
-  string encode(uint16_t code) const {
-    unsigned index = 0;
-    for(unsigned i = 0; i < Count; i++) {
-      if(code >= Base + Size * i && code < Base + Size * (i + 1)) {
-        index = code - (Base + Size * i);
-        break;
-      }
-    }
-    return string() << "MS" << ID << "::" << MouseScancodeName[index];
-  }
-
-  uint16_t operator[](Scancode code) const { return Base + ID * Size + code; }
-  uint16_t axis(unsigned id) const { return Base + Size * ID + Xaxis + id; }
-  uint16_t button(unsigned id) const { return Base + Size * ID + Button0 + id; }
-  bool isAxis(unsigned id) const { return id >= axis(0) && id <= axis(2); }
-  bool isButton(unsigned id) const { return id >= button(0) && id <= button(7); }
-  bool belongsTo(uint16_t scancode) const { return isAxis(scancode) || isButton(scancode); }
-
-  Mouse(unsigned ID_) : ID(ID_) {}
-};
-
-inline Mouse& mouse(unsigned id) {
-  static Mouse ms0(0), ms1(1), ms2(2), ms3(3), ms4(4), ms5(5), ms6(6), ms7(7);
-  switch(id) { default:
-    case 0: return ms0; case 1: return ms1; case 2: return ms2; case 3: return ms3;
-    case 4: return ms4; case 5: return ms5; case 6: return ms6; case 7: return ms7;
-  }
-}
-
-static const char JoypadScancodeName[][64] = {
-  "Hat0", "Hat1", "Hat2", "Hat3", "Hat4", "Hat5", "Hat6", "Hat7",
-  "Axis0", "Axis1", "Axis2", "Axis3", "Axis4", "Axis5", "Axis6", "Axis7",
-  "Axis8", "Axis9", "Axis10", "Axis11", "Axis12", "Axis13", "Axis14", "Axis15",
-  "Button0", "Button1", "Button2", "Button3", "Button4", "Button5", "Button6", "Button7",
-  "Button8", "Button9", "Button10", "Button11", "Button12", "Button13", "Button14", "Button15",
-  "Button16", "Button17", "Button18", "Button19", "Button20", "Button21", "Button22", "Button23",
-  "Button24", "Button25", "Button26", "Button27", "Button28", "Button29", "Button30", "Button31",
-};
-
-struct Joypad;
-Joypad& joypad(unsigned = 0);
-
-struct Joypad {
-  const unsigned ID;
-  enum { Base = Mouse::Base + Mouse::Size * Mouse::Count };
-  enum { Count = 8, Size = 64 };
-  enum { Hats = 8, Axes = 16, Buttons = 32 };
-
-  enum Scancode {
-    Hat0, Hat1, Hat2, Hat3, Hat4, Hat5, Hat6, Hat7,
-    Axis0, Axis1, Axis2, Axis3, Axis4, Axis5, Axis6, Axis7,
-    Axis8, Axis9, Axis10, Axis11, Axis12, Axis13, Axis14, Axis15,
-    Button0, Button1, Button2, Button3, Button4, Button5, Button6, Button7,
-    Button8, Button9, Button10, Button11, Button12, Button13, Button14, Button15,
-    Button16, Button17, Button18, Button19, Button20, Button21, Button22, Button23,
-    Button24, Button25, Button26, Button27, Button28, Button29, Button30, Button31,
-    Limit,
-  };
-
-  enum Hat { HatCenter = 0, HatUp = 1, HatRight = 2, HatDown = 4, HatLeft = 8 };
-
-  static signed numberDecode(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(joypad(i).belongsTo(scancode)) return i;
-    }
-    return -1;
-  }
-
-  static signed hatDecode(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(joypad(i).isHat(scancode)) return scancode - joypad(i).hat(0);
-    }
-    return -1;
-  }
-
-  static signed axisDecode(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(joypad(i).isAxis(scancode)) return scancode - joypad(i).axis(0);
-    }
-    return -1;
-  }
-
-  static signed buttonDecode(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(joypad(i).isButton(scancode)) return scancode - joypad(i).button(0);
-    }
-    return -1;
-  }
-
-  static bool isAnyHat(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(joypad(i).isHat(scancode)) return true;
-    }
-    return false;
-  }
-
-  static bool isAnyAxis(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(joypad(i).isAxis(scancode)) return true;
-    }
-    return false;
-  }
-
-  static bool isAnyButton(uint16_t scancode) {
-    for(unsigned i = 0; i < Count; i++) {
-      if(joypad(i).isButton(scancode)) return true;
-    }
-    return false;
-  }
-
-  static uint16_t decode(const char *name) {
-    string s(name);
-    if(!strbegin(name, "JP")) return 0;
-    s.ltrim("JP");
-    unsigned id = strunsigned(s);
-    auto pos = strpos(s, "::");
-    if(!pos) return 0;
-    s = substr(s, pos() + 2);
-    for(unsigned i = 0; i < Limit; i++) {
-      if(s == JoypadScancodeName[i]) return Base + Size * id + i;
-    }
-    return 0;
-  }
-
-  string encode(uint16_t code) const {
-    unsigned index = 0;
-    for(unsigned i = 0; i < Count; i++) {
-      if(code >= Base + Size * i && code < Base + Size * (i + 1)) {
-        index = code - (Base + Size * i);
-      }
-    }
-    return string() << "JP" << ID << "::" << JoypadScancodeName[index];
-  }
-
-  uint16_t operator[](Scancode code) const { return Base + ID * Size + code; }
-  uint16_t hat(unsigned id) const { return Base + Size * ID + Hat0 + id; }
-  uint16_t axis(unsigned id) const { return Base + Size * ID + Axis0 + id; }
-  uint16_t button(unsigned id) const { return Base + Size * ID + Button0 + id; }
-  bool isHat(unsigned id) const { return id >= hat(0) && id <= hat(7); }
-  bool isAxis(unsigned id) const { return id >= axis(0) && id <= axis(15); }
-  bool isButton(unsigned id) const { return id >= button(0) && id <= button(31); }
-  bool belongsTo(uint16_t scancode) const { return isHat(scancode) || isAxis(scancode) || isButton(scancode); }
-
-  Joypad(unsigned ID_) : ID(ID_) {}
-};
-
-inline Joypad& joypad(unsigned id) {
-  static Joypad jp0(0), jp1(1), jp2(2), jp3(3), jp4(4), jp5(5), jp6(6), jp7(7);
-  switch(id) { default:
-    case 0: return jp0; case 1: return jp1; case 2: return jp2; case 3: return jp3;
-    case 4: return jp4; case 5: return jp5; case 6: return jp6; case 7: return jp7;
-  }
-}
-
-struct Scancode {
-  enum { None = 0, Limit = Joypad::Base + Joypad::Size * Joypad::Count };
-
-  static uint16_t decode(const char *name) {
-    uint16_t code;
-    code = Keyboard::decode(name);
-    if(code) return code;
-    code = Mouse::decode(name);
-    if(code) return code;
-    code = Joypad::decode(name);
-    if(code) return code;
-    return None;
-  }
-
-  static string encode(uint16_t code) {
-    for(unsigned i = 0; i < Keyboard::Count; i++) {
-      if(keyboard(i).belongsTo(code)) return keyboard(i).encode(code);
-    }
-    for(unsigned i = 0; i < Mouse::Count; i++) {
-      if(mouse(i).belongsTo(code)) return mouse(i).encode(code);
-    }
-    for(unsigned i = 0; i < Joypad::Count; i++) {
-      if(joypad(i).belongsTo(code)) return joypad(i).encode(code);
-    }
-    return "None";
-  }
-};
-
-}
-
-#endif

bsnes/nall/lzss.hpp

@@ -1,81 +0,0 @@
-#ifndef NALL_LZSS_HPP
-#define NALL_LZSS_HPP
-
-#include <nall/array.hpp>
-#include <nall/new.hpp>
-#include <nall/stdint.hpp>
-
-namespace nall {
-  class lzss {
-  public:
-    static bool encode(uint8_t *&output, unsigned &outlength, const uint8_t *input, unsigned inlength) {
-      output = new(zeromemory) uint8_t[inlength * 9 / 8 + 9];
-
-      unsigned i = 0, o = 0;
-      while(i < inlength) {
-        unsigned flagoffset = o++;
-        uint8_t flag = 0x00;
-
-        for(unsigned b = 0; b < 8 && i < inlength; b++) {
-          unsigned longest = 0, pointer;
-          for(unsigned index = 1; index < 4096; index++) {
-            unsigned count = 0;
-            while(true) {
-              if(count >= 15 + 3) break;                               //verify pattern match is not longer than max length
-              if(i + count >= inlength) break;                         //verify pattern match does not read past end of input
-              if(i + count < index) break;                             //verify read is not before start of input
-              if(input[i + count] != input[i + count - index]) break;  //verify pattern still matches
-              count++;
-            }
-
-            if(count > longest) {
-              longest = count;
-              pointer = index;
-            }
-          }
-
-          if(longest < 3) output[o++] = input[i++];
-          else {
-            flag |= 1 << b;
-            uint16_t x = ((longest - 3) << 12) + pointer;
-            output[o++] = x;
-            output[o++] = x >> 8;
-            i += longest;
-          }
-        }
-
-        output[flagoffset] = flag;
-      }
-
-      outlength = o;
-      return true;
-    }
-
-    static bool decode(uint8_t *&output, const uint8_t *input, unsigned length) {
-      output = new(zeromemory) uint8_t[length];
-
-      unsigned i = 0, o = 0;
-      while(o < length) {
-        uint8_t flag = input[i++];
-
-        for(unsigned b = 0; b < 8 && o < length; b++) {
-          if(!(flag & (1 << b))) output[o++] = input[i++];
-          else {
-            uint16_t offset = input[i++];
-            offset += input[i++] << 8;
-            uint16_t lookuplength = (offset >> 12) + 3;
-            offset &= 4095;
-            for(unsigned index = 0; index < lookuplength && o + index < length; index++) {
-              output[o + index] = output[o + index - offset];
-            }
-            o += lookuplength;
-          }
-        }
-      }
-
-      return true;
-    }
-  };
-}
-
-#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,122 +0,0 @@
-#ifndef NALL_PLATFORM_HPP
-#define NALL_PLATFORM_HPP
-
-#include <nall/utf8.hpp>
-
-//=========================
-//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>
-
-#if defined(_WIN32)
-  #include <io.h>
-  #include <direct.h>
-  #include <shlobj.h>
-  #undef interface
-  #define dllexport __declspec(dllexport)
-#else
-  #include <unistd.h>
-  #include <pwd.h>
-  #include <sys/stat.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 putenv      _putenv
-  #define mkdir(n, m) _wmkdir(nall::utf16_t(n))
-  #define rmdir       _rmdir
-  #define vsnprintf   _vsnprintf
-  #define usleep(n)   Sleep(n / 1000)
-#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));
-    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));
-    return path;
-  }
-
-  inline char* getcwd(char *path) {
-    wchar_t fp[_MAX_PATH] = L"";
-    _wgetcwd(fp, _MAX_PATH);
-    strcpy(path, nall::utf8_t(fp));
-    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/qt/Makefile

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

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

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

bsnes/nall/qt/concept.hpp

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

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

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

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

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

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

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

bsnes/nall/qt/window.moc.hpp

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

bsnes/nall/random.hpp

@@ -1,20 +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_cyclic {
-    unsigned seed;
-    inline unsigned operator()() {
-      return seed = (seed >> 1) ^ (((seed & 1) - 1) & 0xedb88320);
-    }
-    random_cyclic() : seed(0) {}
-  };
-}
-
-#endif

bsnes/nall/serial.hpp

@@ -1,85 +0,0 @@
-#ifndef NALL_SERIAL_HPP
-#define NALL_SERIAL_HPP
-
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <termios.h>
-#include <unistd.h>
-
-#include <nall/stdint.hpp>
-
-namespace nall {
-  class serial {
-  public:
-    //-1 on error, otherwise return bytes read
-    int read(uint8_t *data, unsigned length) {
-      if(port_open == false) return -1;
-      return ::read(port, (void*)data, length);
-    }
-
-    //-1 on error, otherwise return bytes written
-    int write(const uint8_t *data, unsigned length) {
-      if(port_open == false) return -1;
-      return ::write(port, (void*)data, length);
-    }
-
-    bool open(const char *portname, unsigned rate, bool flowcontrol) {
-      close();
-
-      port = ::open(portname, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK);
-      if(port == -1) return false;
-
-      if(ioctl(port, TIOCEXCL) == -1) { close(); return false; }
-      if(fcntl(port, F_SETFL, 0) == -1) { close(); return false; }
-      if(tcgetattr(port, &original_attr) == -1) { close(); return false; }
-
-      termios attr = original_attr;
-      cfmakeraw(&attr);
-      cfsetspeed(&attr, rate);
-
-      attr.c_lflag &=~ (ECHO | ECHONL | ISIG | ICANON | IEXTEN);
-      attr.c_iflag &=~ (BRKINT | PARMRK | INPCK | ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXOFF | IXANY);
-      attr.c_iflag |=  (IGNBRK | IGNPAR);
-      attr.c_oflag &=~ (OPOST);
-      attr.c_cflag &=~ (CSIZE | CSTOPB | PARENB | CLOCAL);
-      attr.c_cflag |=  (CS8 | CREAD);
-      if(flowcontrol == false) {
-        attr.c_cflag &= ~CRTSCTS;
-      } else {
-        attr.c_cflag |=  CRTSCTS;
-      }
-      attr.c_cc[VTIME] = attr.c_cc[VMIN] = 0;
-
-      if(tcsetattr(port, TCSANOW, &attr) == -1) { close(); return false; }
-      return port_open = true;
-    }
-
-    void close() {
-      if(port != -1) {
-        tcdrain(port);
-        if(port_open == true) {
-          tcsetattr(port, TCSANOW, &original_attr);
-          port_open = false;
-        }
-        ::close(port);
-        port = -1;
-      }
-    }
-
-    serial() {
-      port = -1;
-      port_open = false;
-    }
-
-    ~serial() {
-      close();
-    }
-
-  private:
-    int port;
-    bool port_open;
-    termios original_attr;
-  };
-}
-
-#endif

bsnes/nall/serializer.hpp

@@ -1,145 +0,0 @@
-#ifndef NALL_SERIALIZER_HPP
-#define NALL_SERIALIZER_HPP
-
-#include <type_traits>
-#include <utility>
-#include <nall/stdint.hpp>
-#include <nall/utility.hpp>
-
-namespace nall {
-  //serializer: a class designed to save and restore the state of classes.
-  //
-  //benefits:
-  //- data() will be portable in size (it is not necessary to specify type sizes.)
-  //- data() will be portable in endianness (always stored internally as little-endian.)
-  //- one serialize function can both save and restore class states.
-  //
-  //caveats:
-  //- only plain-old-data can be stored. complex classes must provide serialize(serializer&);
-  //- floating-point usage is not portable across platforms
-
-  class serializer {
-  public:
-    enum mode_t { Load, Save, Size };
-
-    mode_t mode() const {
-      return imode;
-    }
-
-    const uint8_t* data() const {
-      return idata;
-    }
-
-    unsigned size() const {
-      return isize;
-    }
-
-    unsigned capacity() const {
-      return icapacity;
-    }
-
-    template<typename T> void floatingpoint(T &value) {
-      enum { size = sizeof(T) };
-      //this is rather dangerous, and not cross-platform safe;
-      //but there is no standardized way to export FP-values
-      uint8_t *p = (uint8_t*)&value;
-      if(imode == Save) {
-        for(unsigned n = 0; n < size; n++) idata[isize++] = p[n];
-      } else if(imode == Load) {
-        for(unsigned n = 0; n < size; n++) p[n] = idata[isize++];
-      } else {
-        isize += size;
-      }
-    }
-
-    template<typename T> void integer(T &value) {
-      enum { size = std::is_same<bool, T>::value ? 1 : sizeof(T) };
-      if(imode == Save) {
-        for(unsigned n = 0; n < size; n++) idata[isize++] = value >> (n << 3);
-      } else if(imode == Load) {
-        value = 0;
-        for(unsigned n = 0; n < size; n++) value |= idata[isize++] << (n << 3);
-      } else if(imode == Size) {
-        isize += size;
-      }
-    }
-
-    template<typename T> void array(T &array) {
-      enum { size = sizeof(T) / sizeof(typename std::remove_extent<T>::type) };
-      for(unsigned n = 0; n < size; n++) integer(array[n]);
-    }
-
-    template<typename T> void array(T array, unsigned size) {
-      for(unsigned n = 0; n < size; n++) integer(array[n]);
-    }
-
-    //copy
-    serializer& operator=(const serializer &s) {
-      if(idata) delete[] idata;
-
-      imode = s.imode;
-      idata = new uint8_t[s.icapacity];
-      isize = s.isize;
-      icapacity = s.icapacity;
-
-      memcpy(idata, s.idata, s.icapacity);
-      return *this;
-    }
-
-    serializer(const serializer &s) : idata(0) {
-      operator=(s);
-    }
-
-    //move
-    serializer& operator=(serializer &&s) {
-      if(idata) delete[] idata;
-
-      imode = s.imode;
-      idata = s.idata;
-      isize = s.isize;
-      icapacity = s.icapacity;
-
-      s.idata = 0;
-      return *this;
-    }
-
-    serializer(serializer &&s) {
-      operator=(std::move(s));
-    }
-
-    //construction
-    serializer() {
-      imode = Size;
-      idata = 0;
-      isize = 0;
-    }
-
-    serializer(unsigned capacity) {
-      imode = Save;
-      idata = new uint8_t[capacity]();
-      isize = 0;
-      icapacity = capacity;
-    }
-
-    serializer(const uint8_t *data, unsigned capacity) {
-      imode = Load;
-      idata = new uint8_t[capacity];
-      isize = 0;
-      icapacity = capacity;
-      memcpy(idata, data, capacity);
-    }
-
-    ~serializer() {
-      if(idata) delete[] idata;
-    }
-
-  private:
-    mode_t imode;
-    uint8_t *idata;
-    unsigned isize;
-    unsigned icapacity;
-  };
-
-};
-
-#endif

bsnes/nall/sha256.hpp

@@ -1,143 +0,0 @@
-#ifndef NALL_SHA256_HPP
-#define NALL_SHA256_HPP
-
-//author: vladitx
-
-namespace nall {
-  #define PTR(t, a) ((t*)(a))
-
-  #define SWAP32(x) ((uint32_t)(           \
-    (((uint32_t)(x) & 0x000000ff) << 24) | \
-    (((uint32_t)(x) & 0x0000ff00) <<  8) | \
-    (((uint32_t)(x) & 0x00ff0000) >>  8) | \
-    (((uint32_t)(x) & 0xff000000) >> 24)   \
-  ))
-
-  #define ST32(a, d) *PTR(uint32_t, a) = (d)
-  #define ST32BE(a, d) ST32(a, SWAP32(d))
-
-  #define LD32(a) *PTR(uint32_t, a)
-  #define LD32BE(a) SWAP32(LD32(a))
-
-  #define LSL32(x, n) ((uint32_t)(x) << (n))
-  #define LSR32(x, n) ((uint32_t)(x) >> (n))
-  #define ROR32(x, n) (LSR32(x, n) | LSL32(x, 32 - (n)))
-
-  //first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19
-  static const uint32_t T_H[8] = {
-    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
-  };
-
-  //first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311
-  static const uint32_t T_K[64] = {
-    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
-  };
-
-  struct sha256_ctx {
-    uint8_t in[64];
-    unsigned inlen;
-
-    uint32_t w[64];
-    uint32_t h[8];
-    uint64_t len;
-  };
-
-  void sha256_init(sha256_ctx *p) {
-    memset(p, 0, sizeof(sha256_ctx));
-    memcpy(p->h, T_H, sizeof(T_H));
-  }
-
-  static void sha256_block(sha256_ctx *p) {
-    unsigned i;
-    uint32_t s0, s1;
-    uint32_t a, b, c, d, e, f, g, h;
-    uint32_t t1, t2, maj, ch;
-
-    for(i = 0; i < 16; i++) p->w[i] = LD32BE(p->in + i * 4);
-
-    for(i = 16; i < 64; i++) {
-      s0 = ROR32(p->w[i - 15],  7) ^ ROR32(p->w[i - 15], 18) ^ LSR32(p->w[i - 15],  3);
-      s1 = ROR32(p->w[i -  2], 17) ^ ROR32(p->w[i -  2], 19) ^ LSR32(p->w[i -  2], 10);
-      p->w[i] = p->w[i - 16] + s0 + p->w[i - 7] + s1;
-    }
-
-    a = p->h[0]; b = p->h[1]; c = p->h[2]; d = p->h[3];
-    e = p->h[4]; f = p->h[5]; g = p->h[6]; h = p->h[7];
-
-    for(i = 0; i < 64; i++) {
-      s0 = ROR32(a, 2) ^ ROR32(a, 13) ^ ROR32(a, 22);
-      maj = (a & b) ^ (a & c) ^ (b & c);
-      t2 = s0 + maj;
-      s1 = ROR32(e, 6) ^ ROR32(e, 11) ^ ROR32(e, 25);
-      ch = (e & f) ^ (~e & g);
-      t1 = h + s1 + ch + T_K[i] + p->w[i];
-
-      h = g; g = f; f = e; e = d + t1;
-      d = c; c = b; b = a; a = t1 + t2;
-    }
-
-    p->h[0] += a; p->h[1] += b; p->h[2] += c; p->h[3] += d;
-    p->h[4] += e; p->h[5] += f; p->h[6] += g; p->h[7] += h;
-
-    //next block
-    p->inlen = 0;
-  }
-
-  void sha256_chunk(sha256_ctx *p, const uint8_t *s, unsigned len) {
-    unsigned l;
-    p->len += len;
-
-    while(len) {
-      l = 64 - p->inlen;
-      l = (len < l) ? len : l;
-
-      memcpy(p->in + p->inlen, s, l);
-      s += l;
-      p->inlen += l;
-      len -= l;
-
-      if(p->inlen == 64) sha256_block(p);
-    }
-  }
-
-  void sha256_final(sha256_ctx *p) {
-    uint64_t len;
-    p->in[p->inlen++] = 0x80;
-
-    if(p->inlen > 56) {
-      memset(p->in + p->inlen, 0, 64 - p->inlen);
-      sha256_block(p);
-    }
-
-    memset(p->in + p->inlen, 0, 56 - p->inlen);
-
-    len = p->len << 3;
-    ST32BE(p->in + 56, len >> 32);
-    ST32BE(p->in + 60, len);
-    sha256_block(p);
-  }
-
-  void sha256_hash(sha256_ctx *p, uint8_t *s) {
-    uint32_t *t = (uint32_t*)s;
-    for(unsigned i = 0; i < 8; i++) ST32BE(t++, p->h[i]);
-  }
-
-  #undef PTR
-  #undef SWAP32
-  #undef ST32
-  #undef ST32BE
-  #undef LD32
-  #undef LD32BE
-  #undef LSL32
-  #undef LSR32
-  #undef ROR32
-}
-
-#endif

bsnes/nall/snes/info.hpp

@@ -1,864 +0,0 @@
-#ifndef NALL_SNES_INFO_HPP
-#define NALL_SNES_INFO_HPP
-
-namespace nall {
-
-class snes_information {
-public:
-  string xml_memory_map;
-
-  inline snes_information(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);
-  inline unsigned gameboy_ram_size(const uint8_t *data, unsigned size);
-  inline bool gameboy_has_rtc(const uint8_t *data, unsigned size);
-
-  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;
-
-  Mode mode;
-  Type type;
-  Region region;
-  MemoryMapper mapper;
-  DSP1MemoryMapper dsp1_mapper;
-
-  bool has_bsx_slot;
-  bool has_superfx;
-  bool has_sa1;
-  bool has_srtc;
-  bool has_sdd1;
-  bool has_spc7110;
-  bool has_spc7110rtc;
-  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;
-};
-
-snes_information::snes_information(const uint8_t *data, unsigned size) {
-  read_header(data, size);
-
-  string xml = "<?xml version='1.0' encoding='UTF-8'?>\n";
-
-  if(type == TypeBsx) {
-    xml << "<cartridge/>";
-    xml_memory_map = xml;
-    return;
-  }
-
-  if(type == TypeSufamiTurbo) {
-    xml << "<cartridge/>";
-    xml_memory_map = xml;
-    return;
-  }
-
-  if(type == TypeGameBoy) {
-    xml << "<cartridge rtc='" << gameboy_has_rtc(data, size) << "'>\n";
-    if(gameboy_ram_size(data, size) > 0) {
-      xml << "  <ram size='" << strhex(gameboy_ram_size(data, size)) << "'/>\n";
-    }
-    xml << "</cartridge>\n";
-    xml_memory_map = xml;
-    return;
-  }
-
-  xml << "<cartridge";
-  if(region == NTSC) {
-    xml << " region='NTSC'";
-  } else {
-    xml << " region='PAL'";
-  }
-  xml << ">\n";
-
-  if(type == TypeSuperGameBoy1Bios) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='linear' address='00-7f:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='80-ff:8000-ffff'/>\n";
-    xml << "  </rom>\n";
-    xml << "  <supergameboy revision='1'>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:6000-7fff'/>\n";
-    xml << "      <map address='80-bf:6000-7fff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </supergameboy>\n";
-  } else if(type == TypeSuperGameBoy2Bios) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='linear' address='00-7f:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='80-ff:8000-ffff'/>\n";
-    xml << "  </rom>\n";
-    xml << "  <supergameboy revision='2'>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:6000-7fff'/>\n";
-    xml << "      <map address='80-bf:6000-7fff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </supergameboy>\n";
-  } else if(has_spc7110) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='shadow' address='00-0f:8000-ffff'/>\n";
-    xml << "    <map mode='shadow' address='80-bf:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='c0-cf:0000-ffff'/>\n";
-    xml << "  </rom>\n";
-
-    xml << "  <spc7110>\n";
-    xml << "    <mcu>\n";
-    xml << "      <map address='d0-ff:0000-ffff' offset='100000' size='" << strhex(size - 0x100000) << "'/>\n";
-    xml << "    </mcu>\n";
-    xml << "    <ram size='" << strhex(ram_size) << "'>\n";
-    xml << "      <map mode='linear' address='00:6000-7fff'/>\n";
-    xml << "      <map mode='linear' address='30:6000-7fff'/>\n";
-    xml << "    </ram>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:4800-483f'/>\n";
-    xml << "      <map address='80-bf:4800-483f'/>\n";
-    xml << "    </mmio>\n";
-    if(has_spc7110rtc) {
-      xml << "    <rtc>\n";
-      xml << "      <map address='00-3f:4840-4842'/>\n";
-      xml << "      <map address='80-bf:4840-4842'/>\n";
-      xml << "    </rtc>\n";
-    }
-    xml << "    <dcu>\n";
-    xml << "      <map address='50:0000-ffff'/>\n";
-    xml << "    </dcu>\n";
-    xml << "  </spc7110>\n";
-  } else if(mapper == LoROM) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='linear' address='00-7f:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='80-ff:8000-ffff'/>\n";
-    xml << "  </rom>\n";
-
-    if(ram_size > 0) {
-      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
-      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
-      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
-      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
-        xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
-        xml << "    <map mode='linear' address='f0-ff:0000-7fff'/>\n";
-      } else {
-        xml << "    <map mode='linear' address='70-7f:0000-ffff'/>\n";
-        xml << "    <map mode='linear' address='f0-ff:0000-ffff'/>\n";
-      }
-      xml << "  </ram>\n";
-    }
-  } else if(mapper == HiROM) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='shadow' address='00-3f:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='40-7f:0000-ffff'/>\n";
-    xml << "    <map mode='shadow' address='80-bf:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='c0-ff:0000-ffff'/>\n";
-    xml << "  </rom>\n";
-
-    if(ram_size > 0) {
-      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
-      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
-      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
-      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
-        xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
-      } else {
-        xml << "    <map mode='linear' address='70-7f:0000-ffff'/>\n";
-      }
-      xml << "  </ram>\n";
-    }
-  } else if(mapper == ExLoROM) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='linear' address='00-3f:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='40-7f:0000-ffff'/>\n";
-    xml << "    <map mode='linear' address='80-bf:8000-ffff'/>\n";
-    xml << "  </rom>\n";
-
-    if(ram_size > 0) {
-      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
-      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
-      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
-      xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
-      xml << "  </ram>\n";
-    }
-  } else if(mapper == ExHiROM) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='shadow' address='00-3f:8000-ffff' offset='400000'/>\n";
-    xml << "    <map mode='linear' address='40-7f:0000-ffff' offset='400000'/>\n";
-    xml << "    <map mode='shadow' address='80-bf:8000-ffff' offset='000000'/>\n";
-    xml << "    <map mode='linear' address='c0-ff:0000-ffff' offset='000000'/>\n";
-    xml << "  </rom>\n";
-
-    if(ram_size > 0) {
-      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
-      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
-      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
-      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
-        xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
-      } else {
-        xml << "    <map mode='linear' address='70-7f:0000-ffff'/>\n";
-      }
-      xml << "  </ram>\n";
-    }
-  } else if(mapper == SuperFXROM) {
-    xml << "  <superfx revision='2'>\n";
-    xml << "    <rom>\n";
-    xml << "      <map mode='linear' address='00-3f:8000-ffff'/>\n";
-    xml << "      <map mode='linear' address='40-5f:0000-ffff'/>\n";
-    xml << "      <map mode='linear' address='80-bf:8000-ffff'/>\n";
-    xml << "      <map mode='linear' address='c0-df:0000-ffff'/>\n";
-    xml << "    </rom>\n";
-    xml << "    <ram size='" << strhex(ram_size) << "'>\n";
-    xml << "      <map mode='linear' address='00-3f:6000-7fff' size='2000'/>\n";
-    xml << "      <map mode='linear' address='60-7f:0000-ffff'/>\n";
-    xml << "      <map mode='linear' address='80-bf:6000-7fff' size='2000'/>\n";
-    xml << "      <map mode='linear' address='e0-ff:0000-ffff'/>\n";
-    xml << "    </ram>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:3000-32ff'/>\n";
-    xml << "      <map address='80-bf:3000-32ff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </superfx>\n";
-  } else if(mapper == SA1ROM) {
-    xml << "  <sa1>\n";
-    xml << "    <rom>\n";
-    xml << "      <map mode='linear' address='00-3f:8000-ffff'/>\n";
-    xml << "      <map mode='linear' address='80-bf:8000-ffff'/>\n";
-    xml << "      <map mode='linear' address='c0-ff:0000-ffff'/>\n";
-    xml << "    </rom>\n";
-    xml << "    <iram size='800'>\n";
-    xml << "      <map mode='linear' address='00-3f:3000-37ff'/>\n";
-    xml << "      <map mode='linear' address='80-bf:3000-37ff'/>\n";
-    xml << "    </iram>\n";
-    xml << "    <bwram size='" << strhex(ram_size) << "'>\n";
-    xml << "      <map mode='linear' address='00-3f:6000-7fff'/>\n";
-    xml << "      <map mode='linear' address='40-4f:0000-ffff'/>\n";
-    xml << "      <map mode='linear' address='80-bf:6000-7fff'/>\n";
-    xml << "    </bwram>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:2200-23ff'/>\n";
-    xml << "      <map address='80-bf:2200-23ff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </sa1>\n";
-  } else if(mapper == BSCLoROM) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='linear' address='00-1f:8000-ffff' offset='000000'/>\n";
-    xml << "    <map mode='linear' address='20-3f:8000-ffff' offset='100000'/>\n";
-    xml << "    <map mode='linear' address='80-9f:8000-ffff' offset='200000'/>\n";
-    xml << "    <map mode='linear' address='a0-bf:8000-ffff' offset='100000'/>\n";
-    xml << "  </rom>\n";
-    xml << "  <ram size='" << strhex(ram_size) << "'>\n";
-    xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
-    xml << "    <map mode='linear' address='f0-ff:0000-7fff'/>\n";
-    xml << "  </ram>\n";
-    xml << "  <bsx>\n";
-    xml << "    <slot>\n";
-    xml << "      <map mode='linear' address='c0-ef:0000-ffff'/>\n";
-    xml << "    </slot>\n";
-    xml << "  </bsx>\n";
-  } else if(mapper == BSCHiROM) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='shadow' address='00-1f:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='40-5f:0000-ffff'/>\n";
-    xml << "    <map mode='shadow' address='80-9f:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='c0-df:0000-ffff'/>\n";
-    xml << "  </rom>\n";
-    xml << "  <ram size='" << strhex(ram_size) << "'>\n";
-    xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
-    xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
-    xml << "  </ram>\n";
-    xml << "  <bsx>\n";
-    xml << "    <slot>\n";
-    xml << "      <map mode='shadow' address='20-3f:8000-ffff'/>\n";
-    xml << "      <map mode='linear' address='60-7f:0000-ffff'/>\n";
-    xml << "      <map mode='shadow' address='a0-bf:8000-ffff'/>\n";
-    xml << "      <map mode='linear' address='e0-ff:0000-ffff'/>\n";
-    xml << "    </slot>\n";
-    xml << "  </bsx>\n";
-  } else if(mapper == BSXROM) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='linear' address='00-3f:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='80-bf:8000-ffff'/>\n";
-    xml << "  </rom>\n";
-    xml << "  <bsx>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:5000-5fff'/>\n";
-    xml << "      <map address='80-bf:5000-5fff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </bsx>\n";
-  } else if(mapper == STROM) {
-    xml << "  <rom>\n";
-    xml << "    <map mode='linear' address='00-1f:8000-ffff'/>\n";
-    xml << "    <map mode='linear' address='80-9f:8000-ffff'/>\n";
-    xml << "  </rom>\n";
-    xml << "  <sufamiturbo>\n";
-    xml << "    <slot id='A'>\n";
-    xml << "      <rom>\n";
-    xml << "        <map mode='linear' address='20-3f:8000-ffff'/>\n";
-    xml << "        <map mode='linear' address='a0-bf:8000-ffff'/>\n";
-    xml << "      </rom>\n";
-    xml << "      <ram>\n";
-    xml << "        <map mode='linear' address='60-63:8000-ffff'/>\n";
-    xml << "        <map mode='linear' address='e0-e3:8000-ffff'/>\n";
-    xml << "      </ram>\n";
-    xml << "    </slot>\n";
-    xml << "    <slot id='B'>\n";
-    xml << "      <rom>\n";
-    xml << "        <map mode='linear' address='40-5f:8000-ffff'/>\n";
-    xml << "        <map mode='linear' address='c0-df:8000-ffff'/>\n";
-    xml << "      </rom>\n";
-    xml << "      <ram>\n";
-    xml << "        <map mode='linear' address='70-73:8000-ffff'/>\n";
-    xml << "        <map mode='linear' address='f0-f3:8000-ffff'/>\n";
-    xml << "      </ram>\n";
-    xml << "    </slot>\n";
-    xml << "  </sufamiturbo>\n";
-  }
-
-  if(has_srtc) {
-    xml << "  <srtc>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:2800-2801'/>\n";
-    xml << "      <map address='80-bf:2800-2801'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </srtc>\n";
-  }
-
-  if(has_sdd1) {
-    xml << "  <sdd1>\n";
-    xml << "    <mcu>\n";
-    xml << "      <map address='c0-ff:0000-ffff'/>\n";
-    xml << "    </mcu>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:4800-4807'/>\n";
-    xml << "      <map address='80-bf:4800-4807'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </sdd1>\n";
-  }
-
-  if(has_cx4) {
-    xml << "  <cx4>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:6000-7fff'/>\n";
-    xml << "      <map address='80-bf:6000-7fff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </cx4>\n";
-  }
-
-  if(has_dsp1) {
-    xml << "  <necdsp program='DSP-1B'>\n";
-    if(dsp1_mapper == DSP1LoROM1MB) {
-      xml << "    <dr>\n";
-      xml << "      <map address='20-3f:8000-bfff'/>\n";
-      xml << "      <map address='a0-bf:8000-bfff'/>\n";
-      xml << "    </dr>\n";
-      xml << "    <sr>\n";
-      xml << "      <map address='20-3f:c000-ffff'/>\n";
-      xml << "      <map address='a0-bf:c000-ffff'/>\n";
-      xml << "    </sr>\n";
-    } else if(dsp1_mapper == DSP1LoROM2MB) {
-      xml << "    <dr>\n";
-      xml << "      <map address='60-6f:0000-3fff'/>\n";
-      xml << "      <map address='e0-ef:0000-3fff'/>\n";
-      xml << "    </dr>\n";
-      xml << "    <sr>\n";
-      xml << "      <map address='60-6f:4000-7fff'/>\n";
-      xml << "      <map address='e0-ef:4000-7fff'/>\n";
-      xml << "    </sr>\n";
-    } else if(dsp1_mapper == DSP1HiROM) {
-      xml << "    <dr>\n";
-      xml << "      <map address='00-1f:6000-6fff'/>\n";
-      xml << "      <map address='80-9f:6000-6fff'/>\n";
-      xml << "    </dr>\n";
-      xml << "    <sr>\n";
-      xml << "      <map address='00-1f:7000-7fff'/>\n";
-      xml << "      <map address='80-9f:7000-7fff'/>\n";
-      xml << "    </sr>\n";
-    }
-    xml << "  </necdsp>\n";
-  }
-
-  if(has_dsp2) {
-    xml << "  <necdsp program='DSP-2'>\n";
-    xml << "    <dr>\n";
-    xml << "      <map address='20-3f:8000-bfff'/>\n";
-    xml << "      <map address='a0-bf:8000-bfff'/>\n";
-    xml << "    </dr>\n";
-    xml << "    <sr>\n";
-    xml << "      <map address='20-3f:c000-ffff'/>\n";
-    xml << "      <map address='a0-bf:c000-ffff'/>\n";
-    xml << "    </sr>\n";
-    xml << "  </necdsp>\n";
-  }
-
-  if(has_dsp3) {
-    xml << "  <necdsp program='DSP-3'>\n";
-    xml << "    <dr>\n";
-    xml << "      <map address='20-3f:8000-bfff'/>\n";
-    xml << "      <map address='a0-bf:8000-bfff'/>\n";
-    xml << "    </dr>\n";
-    xml << "    <sr>\n";
-    xml << "      <map address='20-3f:c000-ffff'/>\n";
-    xml << "      <map address='a0-bf:c000-ffff'/>\n";
-    xml << "    </sr>\n";
-    xml << "  </necdsp>\n";
-  }
-
-  if(has_dsp4) {
-    xml << "  <necdsp program='DSP-4'>\n";
-    xml << "    <dr>\n";
-    xml << "      <map address='30-3f:8000-bfff'/>\n";
-    xml << "      <map address='b0-bf:8000-bfff'/>\n";
-    xml << "    </dr>\n";
-    xml << "    <sr>\n";
-    xml << "      <map address='30-3f:c000-ffff'/>\n";
-    xml << "      <map address='b0-bf:c000-ffff'/>\n";
-    xml << "    </sr>\n";
-    xml << "  </necdsp>\n";
-  }
-
-  if(has_obc1) {
-    xml << "  <obc1>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:6000-7fff'/>\n";
-    xml << "      <map address='80-bf:6000-7fff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </obc1>\n";
-  }
-
-  if(has_st010) {
-    xml << "  <setadsp program='ST-0010'>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='68-6f:0000-0fff'/>\n";
-    xml << "      <map address='e8-ef:0000-0fff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </setadsp>\n";
-  }
-
-  if(has_st011) {
-    //ST-0011 addresses not verified; chip is unsupported
-    xml << "  <setadsp program='ST-0011'>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='68-6f:0000-0fff'/>\n";
-    xml << "      <map address='e8-ef:0000-0fff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </setadsp>\n";
-  }
-
-  if(has_st018) {
-    xml << "  <setarisc program='ST-0018'>\n";
-    xml << "    <mmio>\n";
-    xml << "      <map address='00-3f:3800-38ff'/>\n";
-    xml << "      <map address='80-bf:3800-38ff'/>\n";
-    xml << "    </mmio>\n";
-    xml << "  </setarisc>\n";
-  }
-
-  xml << "</cartridge>\n";
-  xml_memory_map = xml;
-}
-
-void snes_information::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_srtc       = false;
-  has_sdd1       = false;
-  has_spc7110    = false;
-  has_spc7110rtc = 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;
-    }
-  }
-
-  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
-
-  //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_srtc = 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_spc7110rtc = (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 snes_information::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 snes_information::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;
-}
-
-unsigned snes_information::gameboy_ram_size(const uint8_t *data, unsigned size) {
-  if(size < 512) return 0;
-  switch(data[0x0149]) {
-    case 0x00: return   0 * 1024;
-    case 0x01: return   8 * 1024;
-    case 0x02: return   8 * 1024;
-    case 0x03: return  32 * 1024;
-    case 0x04: return 128 * 1024;
-    case 0x05: return 128 * 1024;
-    default:   return 128 * 1024;
-  }
-}
-
-bool snes_information::gameboy_has_rtc(const uint8_t *data, unsigned size) {
-  if(size < 512) return false;
-  if(data[0x0147] == 0x0f ||data[0x0147] == 0x10) return true;
-  return false;
-}
-
-}
-
-#endif

bsnes/nall/sort.hpp

@@ -1,62 +0,0 @@
-#ifndef NALL_SORT_HPP
-#define NALL_SORT_HPP
-
-#include <nall/utility.hpp>
-
-//class:   merge sort
-//average: O(n log n)
-//worst:   O(n log n)
-//memory:  O(n)
-//stack:   O(log n)
-//stable?: yes
-
-//notes:
-//there are two primary reasons for choosing merge sort
-//over the (usually) faster quick sort*:
-//1: it is a stable sort.
-//2: it lacks O(n^2) worst-case overhead.
-//(* which is also O(n log n) in the average case.)
-
-namespace nall {
-  template<typename T>
-  void sort(T list[], unsigned length) {
-    if(length <= 1) return;  //nothing to sort
-
-    //use insertion sort to quickly sort smaller blocks
-    if(length < 64) {
-      for(unsigned i = 0; i < length; i++) {
-        unsigned min = i;
-        for(unsigned j = i + 1; j < length; j++) {
-          if(list[j] < list[min]) min = j;
-        }
-        if(min != i) swap(list[i], list[min]);
-      }
-      return;
-    }
-
-    //split list in half and recursively sort both
-    unsigned middle = length / 2;
-    sort(list, middle);
-    sort(list + middle, length - middle);
-
-    //left and right are sorted here; perform merge sort
-    T *buffer = new T[length];
-    unsigned offset = 0;
-    unsigned left   = 0;
-    unsigned right  = middle;
-    while(left < middle && right < length) {
-      if(list[left] < list[right]) {
-        buffer[offset++] = list[left++];
-      } else {
-        buffer[offset++] = list[right++];
-      }
-    }
-    while(left  < middle) buffer[offset++] = list[left++];
-    while(right < length) buffer[offset++] = list[right++];
-
-    for(unsigned i = 0; i < length; i++) list[i] = buffer[i];
-    delete[] buffer;
-  }
-}
-
-#endif

bsnes/nall/static.hpp

@@ -1,20 +0,0 @@
-#ifndef NALL_STATIC_HPP
-#define NALL_STATIC_HPP
-
-namespace nall {
-  template<bool C, typename T, typename F> struct static_if { typedef T type; };
-  template<typename T, typename F> struct static_if<false, T, F> { typedef F type; };
-  template<typename C, typename T, typename F> struct mp_static_if { typedef typename static_if<C::type, T, F>::type type; };
-
-  template<bool A, bool B> struct static_and { enum { value = false }; };
-  template<> struct static_and<true, true> { enum { value = true }; };
-  template<typename A, typename B> struct mp_static_and { enum { value = static_and<A::value, B::value>::value }; };
-
-  template<bool A, bool B> struct static_or { enum { value = false }; };
-  template<> struct static_or<false, true> { enum { value = true }; };
-  template<> struct static_or<true, false> { enum { value = true }; };
-  template<> struct static_or<true, true> { enum { value = true }; };
-  template<typename A, typename B> struct mp_static_or { enum { value = static_or<A::value, B::value>::value }; };
-}
-
-#endif

bsnes/nall/stdint.hpp

@@ -1,44 +0,0 @@
-#ifndef NALL_STDINT_HPP
-#define NALL_STDINT_HPP
-
-#include <nall/static.hpp>
-
-#if defined(_MSC_VER)
-  typedef signed char int8_t;
-  typedef signed short int16_t;
-  typedef signed int int32_t;
-  typedef signed long long int64_t;
-  typedef int64_t intmax_t;
-  #if defined(_WIN64)
-  typedef int64_t intptr_t;
-  #else
-  typedef int32_t intptr_t;
-  #endif
-
-  typedef unsigned char uint8_t;
-  typedef unsigned short uint16_t;
-  typedef unsigned int uint32_t;
-  typedef unsigned long long uint64_t;
-  typedef uint64_t uintmax_t;
-  #if defined(_WIN64)
-  typedef uint64_t uintptr_t;
-  #else
-  typedef uint32_t uintptr_t;
-  #endif
-#else
-  #include <stdint.h>
-#endif
-
-namespace nall {
-  static_assert(sizeof(int8_t)   == 1, "int8_t is not of the correct size" );
-  static_assert(sizeof(int16_t)  == 2, "int16_t is not of the correct size");
-  static_assert(sizeof(int32_t)  == 4, "int32_t is not of the correct size");
-  static_assert(sizeof(int64_t)  == 8, "int64_t is not of the correct size");
-
-  static_assert(sizeof(uint8_t)  == 1, "int8_t is not of the correct size" );
-  static_assert(sizeof(uint16_t) == 2, "int16_t is not of the correct size");
-  static_assert(sizeof(uint32_t) == 4, "int32_t is not of the correct size");
-  static_assert(sizeof(uint64_t) == 8, "int64_t is not of the correct size");
-}
-
-#endif

bsnes/nall/string.hpp

@@ -1,30 +0,0 @@
-#ifndef NALL_STRING_HPP
-#define NALL_STRING_HPP
-
-#include <initializer_list>
-#include <nall/utility.hpp>
-
-#include <nall/string/base.hpp>
-#include <nall/string/bsv.hpp>
-#include <nall/string/core.hpp>
-#include <nall/string/cast.hpp>
-#include <nall/string/compare.hpp>
-#include <nall/string/convert.hpp>
-#include <nall/string/filename.hpp>
-#include <nall/string/match.hpp>
-#include <nall/string/math.hpp>
-#include <nall/string/strl.hpp>
-#include <nall/string/strpos.hpp>
-#include <nall/string/trim.hpp>
-#include <nall/string/replace.hpp>
-#include <nall/string/split.hpp>
-#include <nall/string/utility.hpp>
-#include <nall/string/variadic.hpp>
-#include <nall/string/xml.hpp>
-
-namespace nall {
-  template<> struct has_length<string> { enum { value = true }; };
-  template<> struct has_size<lstring> { enum { value = true }; };
-}
-
-#endif

bsnes/nall/string/base.hpp

@@ -1,141 +0,0 @@
-#ifndef NALL_STRING_BASE_HPP
-#define NALL_STRING_BASE_HPP
-
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <nall/concept.hpp>
-#include <nall/stdint.hpp>
-#include <nall/utf8.hpp>
-#include <nall/vector.hpp>
-
-namespace nall {
-  class string;
-  template<typename T> inline string to_string(T);
-
-  class string {
-  public:
-    inline void reserve(unsigned);
-    inline unsigned length() const;
-
-    inline string& assign(const char*);
-    inline string& append(const char*);
-    inline string& append(bool);
-    inline string& append(signed int value);
-    inline string& append(unsigned int value);
-    inline string& append(double value);
-
-    template<typename T> inline string& operator= (T value);
-    template<typename T> inline string& operator<<(T value);
-
-    inline operator const char*() const;
-    inline char* operator()();
-    inline char& operator[](int);
-
-    inline bool operator==(const char*) const;
-    inline bool operator!=(const char*) const;
-    inline bool operator< (const char*) const;
-    inline bool operator<=(const char*) const;
-    inline bool operator> (const char*) const;
-    inline bool operator>=(const char*) const;
-
-    inline string& operator=(const string&);
-    inline string& operator=(string&&);
-
-    template<typename... Args> inline string(Args&&... args);
-    inline string(const string&);
-    inline string(string&&);
-    inline ~string();
-
-    inline bool readfile(const char*);
-    inline string& replace (const char*, const char*);
-    inline string& qreplace(const char*, const char*);
-
-    inline string& lower();
-    inline string& upper();
-    inline string& transform(const char *before, const char *after);
-    inline string& ltrim(const char *key = " ");
-    inline string& rtrim(const char *key = " ");
-    inline string& trim (const char *key = " ");
-    inline string& ltrim_once(const char *key = " ");
-    inline string& rtrim_once(const char *key = " ");
-    inline string& trim_once (const char *key = " ");
-
-  protected:
-    char *data;
-    unsigned size;
-
-  #if defined(QSTRING_H)
-  public:
-    inline operator QString() const;
-  #endif
-  };
-
-  class lstring : public linear_vector<string> {
-  public:
-    template<typename T> inline lstring& operator<<(T value);
-
-    inline optional<unsigned> find(const char*);
-    inline void split (const char*, const char*, unsigned = 0);
-    inline void qsplit(const char*, const char*, unsigned = 0);
-
-    lstring();
-    lstring(std::initializer_list<string>);
-  };
-
-  //compare.hpp
-  inline char chrlower(char c);
-  inline char chrupper(char c);
-  inline int stricmp(const char *dest, const char *src);
-  inline bool strbegin (const char *str, const char *key);
-  inline bool stribegin(const char *str, const char *key);
-  inline bool strend (const char *str, const char *key);
-  inline bool striend(const char *str, const char *key);
-
-  //convert.hpp
-  inline char* strlower(char *str);
-  inline char* strupper(char *str);
-  inline char* strtr(char *dest, const char *before, const char *after);
-  inline uintmax_t strhex     (const char *str);
-  inline intmax_t  strsigned  (const char *str);
-  inline uintmax_t strunsigned(const char *str);
-  inline uintmax_t strbin     (const char *str);
-  inline double    strdouble  (const char *str);
-
-  //match.hpp
-  inline bool match(const char *pattern, const char *str);
-
-  //math.hpp
-  inline bool strint (const char *str, int &result);
-  inline bool strmath(const char *str, int &result);
-
-  //strl.hpp
-  inline unsigned strlcpy(char *dest, const char *src, unsigned length);
-  inline unsigned strlcat(char *dest, const char *src, unsigned length);
-
-  //trim.hpp
-  inline char* ltrim(char *str, const char *key = " ");
-  inline char* rtrim(char *str, const char *key = " ");
-  inline char* trim (char *str, const char *key = " ");
-  inline char* ltrim_once(char *str, const char *key = " ");
-  inline char* rtrim_once(char *str, const char *key = " ");
-  inline char* trim_once (char *str, const char *key = " ");
-
-  //utility.hpp
-  inline unsigned strlcpy(string &dest, const char *src, unsigned length);
-  inline unsigned strlcat(string &dest, const char *src, unsigned length);
-  inline string substr(const char *src, unsigned start = 0, unsigned length = 0);
-  inline string& strtr(string &dest, const char *before, const char *after);
-  template<unsigned length = 0, char padding = '0'> inline string strhex(uintmax_t value);
-  template<unsigned length = 0, char padding = '0'> inline string strsigned(intmax_t value);
-  template<unsigned length = 0, char padding = '0'> inline string strunsigned(uintmax_t value);
-  template<unsigned length = 0, char padding = '0'> inline string strbin(uintmax_t value);
-  inline unsigned strdouble(char *str, double value);
-  inline string strdouble(double value);
-
-  //variadic.hpp
-  template<typename... Args> inline void print(Args&&... args);
-};
-
-#endif

bsnes/nall/string/bsv.hpp

@@ -1,75 +0,0 @@
-#ifndef NALL_STRING_BSV_HPP
-#define NALL_STRING_BSV_HPP
-
-//BSV parser
-//version 0.01
-
-namespace nall {
-
-inline string bsv_decode(const char *input) {
-  string output;
-  unsigned offset = 0;
-  while(*input) {
-    //illegal characters
-    if(*input == '}' ) return "";
-    if(*input == '\r') return "";
-    if(*input == '\n') return "";
-
-    //normal characters
-    if(*input != '{') { output[offset++] = *input++;  continue; }
-
-    //entities
-    if(strbegin(input, "{lf}")) { output[offset++] = '\n'; input += 4; continue; }
-    if(strbegin(input, "{lb}")) { output[offset++] = '{';  input += 4; continue; }
-    if(strbegin(input, "{rb}")) { output[offset++] = '}';  input += 4; continue; }
-
-    //illegal entities
-    return "";
-  }
-  output[offset] = 0;
-  return output;
-}
-
-inline string bsv_encode(const char *input) {
-  string output;
-  unsigned offset = 0;
-  while(*input) {
-    //illegal characters
-    if(*input == '\r') return "";
-
-    if(*input == '\n') {
-      output[offset++] = '{';
-      output[offset++] = 'l';
-      output[offset++] = 'f';
-      output[offset++] = '}';
-      input++;
-      continue;
-    }
-
-    if(*input == '{') {
-      output[offset++] = '{';
-      output[offset++] = 'l';
-      output[offset++] = 'b';
-      output[offset++] = '}';
-      input++;
-      continue;
-    }
-
-    if(*input == '}') {
-      output[offset++] = '{';
-      output[offset++] = 'r';
-      output[offset++] = 'b';
-      output[offset++] = '}';
-      input++;
-      continue;
-    }
-
-    output[offset++] = *input++;
-  }
-  output[offset] = 0;
-  return output;
-}
-
-}
-
-#endif

bsnes/nall/string/cast.hpp

@@ -1,32 +0,0 @@
-#ifndef NALL_STRING_CAST_HPP
-#define NALL_STRING_CAST_HPP
-
-namespace nall {
-
-//this is needed, as C++0x does not support explicit template specialization inside classes
-template<> inline string to_string<bool>         (bool v)          { return v ? "true" : "false"; }
-template<> inline string to_string<signed int>   (signed int v)    { return strsigned(v); }
-template<> inline string to_string<unsigned int> (unsigned int v)  { return strunsigned(v); }
-template<> inline string to_string<double>       (double v)        { return strdouble(v); }
-template<> inline string to_string<char*>        (char *v)         { return v; }
-template<> inline string to_string<const char*>  (const char *v)   { return v; }
-template<> inline string to_string<string>       (string v)        { return v; }
-template<> inline string to_string<const string&>(const string &v) { return v; }
-
-template<typename T> string& string::operator= (T value) { return assign(to_string<T>(value)); }
-template<typename T> string& string::operator<<(T value) { return append(to_string<T>(value)); }
-
-template<typename T> lstring& lstring::operator<<(T value) {
-  operator[](size()).assign(to_string<T>(value));
-  return *this;
-}
-
-#if defined(QSTRING_H)
-template<> inline string to_string<QString>(QString v) { return v.toUtf8().constData(); }
-template<> inline string to_string<const QString&>(const QString &v) { return v.toUtf8().constData(); }
-string::operator QString() const { return QString::fromUtf8(*this); }
-#endif
-
-}
-
-#endif

bsnes/nall/string/compare.hpp

@@ -1,72 +0,0 @@
-#ifndef NALL_STRING_COMPARE_HPP
-#define NALL_STRING_COMPARE_HPP
-
-namespace nall {
-
-char chrlower(char c) {
-  return (c >= 'A' && c <= 'Z') ? c + ('a' - 'A') : c;
-}
-
-char chrupper(char c) {
-  return (c >= 'a' && c <= 'z') ? c - ('a' - 'A') : c;
-}
-
-int stricmp(const char *dest, const char *src) {
-  while(*dest) {
-    if(chrlower(*dest) != chrlower(*src)) break;
-    dest++;
-    src++;
-  }
-
-  return (int)chrlower(*dest) - (int)chrlower(*src);
-}
-
-bool strbegin(const char *str, const char *key) {
-  int i, ssl = strlen(str), ksl = strlen(key);
-
-  if(ksl > ssl) return false;
-  return (!memcmp(str, key, ksl));
-}
-
-bool stribegin(const char *str, const char *key) {
-  int ssl = strlen(str), ksl = strlen(key);
-
-  if(ksl > ssl) return false;
-  for(int i = 0; i < ksl; i++) {
-    if(str[i] >= 'A' && str[i] <= 'Z') {
-      if(str[i] != key[i] && str[i]+0x20 != key[i])return false;
-    } else if(str[i] >= 'a' && str[i] <= 'z') {
-      if(str[i] != key[i] && str[i]-0x20 != key[i])return false;
-    } else {
-      if(str[i] != key[i])return false;
-    }
-  }
-  return true;
-}
-
-bool strend(const char *str, const char *key) {
-  int ssl = strlen(str), ksl = strlen(key);
-
-  if(ksl > ssl) return false;
-  return (!memcmp(str + ssl - ksl, key, ksl));
-}
-
-bool striend(const char *str, const char *key) {
-  int ssl = strlen(str), ksl = strlen(key);
-
-  if(ksl > ssl) return false;
-  for(int i = ssl - ksl, z = 0; i < ssl; i++, z++) {
-    if(str[i] >= 'A' && str[i] <= 'Z') {
-      if(str[i] != key[z] && str[i]+0x20 != key[z])return false;
-    } else if(str[i] >= 'a' && str[i] <= 'z') {
-      if(str[i] != key[z] && str[i]-0x20 != key[z])return false;
-    } else {
-      if(str[i] != key[z])return false;
-    }
-  }
-  return true;
-}
-
-}
-
-#endif

bsnes/nall/string/convert.hpp

@@ -1,157 +0,0 @@
-#ifndef NALL_STRING_CONVERT_HPP
-#define NALL_STRING_CONVERT_HPP
-
-namespace nall {
-
-char* strlower(char *str) {
-  if(!str) return 0;
-  int i = 0;
-  while(str[i]) {
-    str[i] = chrlower(str[i]);
-    i++;
-  }
-  return str;
-}
-
-char* strupper(char *str) {
-  if(!str) return 0;
-  int i = 0;
-  while(str[i]) {
-    str[i] = chrupper(str[i]);
-    i++;
-  }
-  return str;
-}
-
-char* strtr(char *dest, const char *before, const char *after) {
-  if(!dest || !before || !after) return dest;
-  int sl = strlen(dest), bsl = strlen(before), asl = strlen(after);
-
-  if(bsl != asl || bsl == 0) return dest;  //patterns must be the same length for 1:1 replace
-  for(unsigned i = 0; i < sl; i++) {
-    for(unsigned l = 0; l < bsl; l++) {
-      if(dest[i] == before[l]) {
-        dest[i] = after[l];
-        break;
-      }
-    }
-  }
-
-  return dest;
-}
-
-string& string::lower() { nall::strlower(data); return *this; }
-string& string::upper() { nall::strupper(data); return *this; }
-string& string::transform(const char *before, const char *after) { nall::strtr(data, before, after); return *this; }
-
-uintmax_t strhex(const char *str) {
-  if(!str) return 0;
-  uintmax_t result = 0;
-
-  //skip hex identifiers 0x and $, if present
-  if(*str == '0' && (*(str + 1) == 'X' || *(str + 1) == 'x')) str += 2;
-  else if(*str == '$') str++;
-
-  while(*str) {
-    uint8_t x = *str++;
-    if(x >= '0' && x <= '9') x -= '0';
-    else if(x >= 'A' && x <= 'F') x -= 'A' - 10;
-    else if(x >= 'a' && x <= 'f') x -= 'a' - 10;
-    else break;  //stop at first invalid character
-    result = result * 16 + x;
-  }
-
-  return result;
-}
-
-intmax_t strsigned(const char *str) {
-  if(!str) return 0;
-  intmax_t result = 0;
-  bool negate = false;
-
-  //check for negation
-  if(*str == '-') {
-    negate = true;
-    str++;
-  }
-
-  while(*str) {
-    uint8_t x = *str++;
-    if(x >= '0' && x <= '9') x -= '0';
-    else break;  //stop at first invalid character
-    result = result * 10 + x;
-  }
-
-  return !negate ? result : -result;
-}
-
-uintmax_t strunsigned(const char *str) {
-  if(!str) return 0;
-  uintmax_t result = 0;
-
-  while(*str) {
-    uint8_t x = *str++;
-    if(x >= '0' && x <= '9') x -= '0';
-    else break;  //stop at first invalid character
-    result = result * 10 + x;
-  }
-
-  return result;
-}
-
-uintmax_t strbin(const char *str) {
-  if(!str) return 0;
-  uintmax_t result = 0;
-
-  //skip bin identifiers 0b and %, if present
-  if(*str == '0' && (*(str + 1) == 'B' || *(str + 1) == 'b')) str += 2;
-  else if(*str == '%') str++;
-
-  while(*str) {
-    uint8_t x = *str++;
-    if(x == '0' || x == '1') x -= '0';
-    else break;  //stop at first invalid character
-    result = result * 2 + x;
-  }
-
-  return result;
-}
-
-double strdouble(const char *str) {
-  if(!str) return 0.0;
-  bool negate = false;
-
-  //check for negation
-  if(*str == '-') {
-    negate = true;
-    str++;
-  }
-
-  intmax_t result_integral = 0;
-  while(*str) {
-    uint8_t x = *str++;
-    if(x >= '0' && x <= '9') x -= '0';
-    else if(x == '.' || x == ',') break;  //break loop and read fractional part
-    else return (double)result_integral;  //invalid value, assume no fractional part
-    result_integral = result_integral * 10 + x;
-  }
-
-  intmax_t result_fractional = 0;
-  while(*str) {
-    uint8_t x = *str++;
-    if(x >= '0' && x <= '9') x -= '0';
-    else break;  //stop at first invalid character
-    result_fractional = result_fractional * 10 + x;
-  }
-
-  //calculate fractional portion
-  double result = (double)result_fractional;
-  while((uintmax_t)result > 0) result /= 10.0;
-  result += (double)result_integral;
-
-  return !negate ? result : -result;
-}
-
-}
-
-#endif

bsnes/nall/string/core.hpp

@@ -1,143 +0,0 @@
-#ifndef NALL_STRING_CORE_HPP
-#define NALL_STRING_CORE_HPP
-
-namespace nall {
-
-void string::reserve(unsigned size_) {
-  if(size_ > size) {
-    size = size_;
-    data = (char*)realloc(data, size + 1);
-    data[size] = 0;
-  }
-}
-
-unsigned string::length() const {
-  return strlen(data);
-}
-
-string& string::assign(const char *s) {
-  unsigned length = strlen(s);
-  reserve(length);
-  strcpy(data, s);
-  return *this;
-}
-
-string& string::append(const char *s) {
-  unsigned length = strlen(data) + strlen(s);
-  reserve(length);
-  strcat(data, s);
-  return *this;
-}
-
-string& string::append(bool value) { append(value ? "true" : "false"); return *this; }
-string& string::append(signed int value) { append(strsigned(value)); return *this; }
-string& string::append(unsigned int value) { append(strunsigned(value)); return *this; }
-string& string::append(double value) { append(strdouble(value)); return *this; }
-
-string::operator const char*() const {
-  return data;
-}
-
-char* string::operator()() {
-  return data;
-}
-
-char& string::operator[](int index) {
-  reserve(index);
-  return data[index];
-}
-
-bool string::operator==(const char *str) const { return strcmp(data, str) == 0; }
-bool string::operator!=(const char *str) const { return strcmp(data, str) != 0; }
-bool string::operator< (const char *str) const { return strcmp(data, str)  < 0; }
-bool string::operator<=(const char *str) const { return strcmp(data, str) <= 0; }
-bool string::operator> (const char *str) const { return strcmp(data, str)  > 0; }
-bool string::operator>=(const char *str) const { return strcmp(data, str) >= 0; }
-
-string& string::operator=(const string &value) {
-  assign(value);
-  return *this;
-}
-
-string& string::operator=(string &&source) {
-  if(data) free(data);
-  size = source.size;
-  data = source.data;
-  source.data = 0;
-  source.size = 0;
-  return *this;
-}
-
-static void istring(string &output) {
-}
-
-template<typename T, typename... Args>
-static void istring(string &output, const T &value, Args&&... args) {
-  output.append(value);
-  istring(output, std::forward<Args>(args)...);
-}
-
-template<typename... Args> string::string(Args&&... args) {
-  size = 64;
-  data = (char*)malloc(size + 1);
-  *data = 0;
-  istring(*this, std::forward<Args>(args)...);
-}
-
-string::string(const string &value) {
-  size = strlen(value);
-  data = strdup(value);
-}
-
-string::string(string &&source) {
-  size = source.size;
-  data = source.data;
-  source.data = 0;
-}
-
-string::~string() {
-  if(data) free(data);
-}
-
-bool string::readfile(const char *filename) {
-  assign("");
-
-  #if !defined(_WIN32)
-  FILE *fp = fopen(filename, "rb");
-  #else
-  FILE *fp = _wfopen(utf16_t(filename), L"rb");
-  #endif
-  if(!fp) return false;
-
-  fseek(fp, 0, SEEK_END);
-  unsigned size = ftell(fp);
-  rewind(fp);
-  char *fdata = new char[size + 1];
-  unsigned unused = fread(fdata, 1, size, fp);
-  fclose(fp);
-  fdata[size] = 0;
-  assign(fdata);
-  delete[] fdata;
-
-  return true;
-}
-
-optional<unsigned> lstring::find(const char *key) {
-  for(unsigned i = 0; i < size(); i++) {
-    if(operator[](i) == key) return { true, i };
-  }
-  return { false, 0 };
-}
-
-inline lstring::lstring() {
-}
-
-inline lstring::lstring(std::initializer_list<string> list) {
-  for(const string *s = list.begin(); s != list.end(); ++s) {
-    operator<<(*s);
-  }
-}
-
-}
-
-#endif

bsnes/nall/string/filename.hpp

@@ -1,61 +0,0 @@
-#ifndef NALL_FILENAME_HPP
-#define NALL_FILENAME_HPP
-
-namespace nall {
-
-// "foo/bar.c" -> "foo/", "bar.c" -> "./"
-inline string dir(char const *name) {
-  string result = name;
-  for(signed i = strlen(result); i >= 0; i--) {
-    if(result[i] == '/' || result[i] == '\\') {
-      result[i + 1] = 0;
-      break;
-    }
-    if(i == 0) result = "./";
-  }
-  return result;
-}
-
-// "foo/bar.c" -> "bar.c"
-inline string notdir(char const *name) {
-  for(signed i = strlen(name); i >= 0; i--) {
-    if(name[i] == '/' || name[i] == '\\') {
-      name += i + 1;
-      break;
-    }
-  }
-  string result = name;
-  return result;
-}
-
-// "foo/bar.c" -> "foo/bar"
-inline string basename(char const *name) {
-  string result = name;
-  for(signed i = strlen(result); i >= 0; i--) {
-    if(result[i] == '/' || result[i] == '\\') {
-      //file has no extension
-      break;
-    }
-    if(result[i] == '.') {
-      result[i] = 0;
-      break;
-    }
-  }
-  return result;
-}
-
-// "foo/bar.c" -> "c"
-inline string extension(char const *name) {
-  for(signed i = strlen(name); i >= 0; i--) {
-    if(name[i] == '.') {
-      name += i + 1;
-      break;
-    }
-  }
-  string result = name;
-  return result;
-}
-
-}
-
-#endif

bsnes/nall/string/match.hpp

@@ -1,76 +0,0 @@
-#ifndef NALL_STRING_MATCH_HPP
-#define NALL_STRING_MATCH_HPP
-
-namespace nall {
-
-bool match(const char *p, const char *s) {
-  const char *p_ = 0, *s_ = 0;
-
-  for(;;) {
-    if(!*s) {
-      while(*p == '*') p++;
-      return !*p;
-    }
-
-    //wildcard match
-    if(*p == '*') {
-      p_ = p++, s_ = s;
-      continue;
-    }
-
-    //any match
-    if(*p == '?') {
-      p++, s++;
-      continue;
-    }
-
-    //ranged match
-    if(*p == '{') {
-      #define pattern(name_, rule_) \
-        if(strbegin(p, name_)) { \
-          if(rule_) { \
-            p += sizeof(name_) - 1, s++; \
-            continue; \
-          } \
-          goto failure; \
-        }
-
-      pattern("{alpha}",        (*s >= 'A' && *s <= 'Z') || (*s >= 'a' && *s <= 'z'))
-      pattern("{alphanumeric}", (*s >= 'A' && *s <= 'Z') || (*s >= 'a' && *s <= 'z') || (*s >= '0' && *s <= '9'))
-      pattern("{binary}",       (*s == '0' || *s == '1'))
-      pattern("{hex}",          (*s >= '0' && *s <= '9') || (*s >= 'A' && *s <= 'F') || (*s >= 'a' && *s <= 'f'))
-      pattern("{lowercase}",    (*s >= 'a' && *s <= 'z'))
-      pattern("{numeric}",      (*s >= '0' && *s <= '9'))
-      pattern("{uppercase}",    (*s >= 'A' && *s <= 'Z'))
-      pattern("{whitespace}",   (*s == ' ' || *s == '\t'))
-
-      #undef pattern
-      goto failure;
-    }
-
-    //reserved character match
-    if(*p == '\\') {
-      p++;
-    //fallthrough
-    }
-
-    //literal match
-    if(*p == *s) {
-      p++, *s++;
-      continue;
-    }
-
-    //attempt wildcard rematch
-    failure:
-    if(p_) {
-      p = p_, s = s_ + 1;
-      continue;
-    }
-
-    return false;
-  }
-}
-
-}
-
-#endif

bsnes/nall/string/math.hpp

@@ -1,164 +0,0 @@
-#ifndef NALL_STRING_MATH_HPP
-#define NALL_STRING_MATH_HPP
-
-namespace nall {
-
-static int eval_integer(const char *&s) {
-  if(!*s) throw "unrecognized_integer";
-  int value = 0, x = *s, y = *(s + 1);
-
-  //hexadecimal
-  if(x == '0' && (y == 'X' || y == 'x')) {
-    s += 2;
-    while(true) {
-      if(*s >= '0' && *s <= '9') { value = value * 16 + (*s++ - '0');      continue; }
-      if(*s >= 'A' && *s <= 'F') { value = value * 16 + (*s++ - 'A' + 10); continue; }
-      if(*s >= 'a' && *s <= 'f') { value = value * 16 + (*s++ - 'a' + 10); continue; }
-      return value;
-    }
-  }
-
-  //binary
-  if(x == '0' && (y == 'B' || y == 'b')) {
-    s += 2;
-    while(true) {
-      if(*s == '0' || *s == '1') { value = value * 2 + (*s++ - '0'); continue; }
-      return value;
-    }
-  }
-
-  //octal (or decimal '0')
-  if(x == '0') {
-    s += 1;
-    while(true) {
-      if(*s >= '0' && *s <= '7') { value = value * 8 + (*s++ - '0'); continue; }
-      return value;
-    }
-  }
-
-  //decimal
-  if(x >= '0' && x <= '9') {
-    while(true) {
-      if(*s >= '0' && *s <= '9') { value = value * 10 + (*s++ - '0'); continue; }
-      return value;
-    }
-  }
-
-  //char
-  if(x == '\'' && y != '\'') {
-    s += 1;
-    while(true) {
-      value = value * 256 + *s++;
-      if(*s == '\'') { s += 1; return value; }
-      if(!*s) throw "mismatched_char";
-    }
-  }
-
-  throw "unrecognized_integer";
-}
-
-static int eval(const char *&s, int depth = 0) {
-  while(*s == ' ' || *s == '\t') s++; //trim whitespace
-  if(!*s) throw "unrecognized_token";
-  int value = 0, x = *s, y = *(s + 1);
-
-  if(*s == '(') {
-    value = eval(++s, 1);
-    if(*s++ != ')') throw "mismatched_group";
-  }
-
-  else if(x == '!') value = !eval(++s, 13);
-  else if(x == '~') value = ~eval(++s, 13);
-  else if(x == '+') value = +eval(++s, 13);
-  else if(x == '-') value = -eval(++s, 13);
-
-  else if((x >= '0' && x <= '9') || x == '\'') value = eval_integer(s);
-
-  else throw "unrecognized_token";
-
-  while(true) {
-    while(*s == ' ' || *s == '\t') s++; //trim whitespace
-    if(!*s) break;
-    x = *s, y = *(s + 1);
-
-    if(depth >= 13) break;
-    if(x == '*') { value *= eval(++s, 13); continue; }
-    if(x == '/') { value /= eval(++s, 13); continue; }
-    if(x == '%') { value %= eval(++s, 13); continue; }
-
-    if(depth >= 12) break;
-    if(x == '+') { value += eval(++s, 12); continue; }
-    if(x == '-') { value -= eval(++s, 12); continue; }
-
-    if(depth >= 11) break;
-    if(x == '<' && y == '<') { value <<= eval(++++s, 11); continue; }
-    if(x == '>' && y == '>') { value >>= eval(++++s, 11); continue; }
-
-    if(depth >= 10) break;
-    if(x == '<' && y == '=') { value = value <= eval(++++s, 10); continue; }
-    if(x == '>' && y == '=') { value = value >= eval(++++s, 10); continue; }
-    if(x == '<') { value = value < eval(++s, 10); continue; }
-    if(x == '>') { value = value > eval(++s, 10); continue; }
-
-    if(depth >= 9) break;
-    if(x == '=' && y == '=') { value = value == eval(++++s, 9); continue; }
-    if(x == '!' && y == '=') { value = value != eval(++++s, 9); continue; }
-
-    if(depth >= 8) break;
-    if(x == '&' && y != '&') { value = value & eval(++s, 8); continue; }
-
-    if(depth >= 7) break;
-    if(x == '^' && y != '^') { value = value ^ eval(++s, 7); continue; }
-
-    if(depth >= 6) break;
-    if(x == '|' && y != '|') { value = value | eval(++s, 6); continue; }
-
-    if(depth >= 5) break;
-    if(x == '&' && y == '&') { value = eval(++++s, 5) && value; continue; }
-
-    if(depth >= 4) break;
-    if(x == '^' && y == '^') { value = (!eval(++++s, 4) != !value); continue; }
-
-    if(depth >= 3) break;
-    if(x == '|' && y == '|') { value = eval(++++s, 3) || value; continue; }
-
-    if(x == '?') {
-      int lhs = eval(++s, 2);
-      if(*s != ':') throw "mismatched_ternary";
-      int rhs = eval(++s, 2);
-      value = value ? lhs : rhs;
-      continue;
-    }
-    if(depth >= 2) break;
-
-    if(depth > 0 && x == ')') break;
-
-    throw "unrecognized_token";
-  }
-
-  return value;
-}
-
-bool strint(const char *s, int &result) {
-  try {
-    result = eval_integer(s);
-    return true;
-  } catch(const char*) {
-    result = 0;
-    return false;
-  }
-}
-
-bool strmath(const char *s, int &result) {
-  try {
-    result = eval(s);
-    return true;
-  } catch(const char*) {
-    result = 0;
-    return false;
-  }
-}
-
-}
-
-#endif

bsnes/nall/string/replace.hpp

@@ -1,103 +0,0 @@
-#ifndef NALL_STRING_REPLACE_HPP
-#define NALL_STRING_REPLACE_HPP
-
-namespace nall {
-
-string& string::replace(const char *key, const char *token) {
-  int i, z, ksl = strlen(key), tsl = strlen(token), ssl = length();
-  unsigned int replace_count = 0, size = ssl;
-  char *buffer;
-
-  if(ksl <= ssl) {
-    if(tsl > ksl) {                      //the new string may be longer than the old string...
-      for(i = 0; i <= ssl - ksl;) {      //so let's find out how big of a string we'll need...
-        if(!memcmp(data + i, key, ksl)) {
-          replace_count++;
-          i += ksl;
-        } else i++;
-      }
-      size = ssl + ((tsl - ksl) * replace_count);
-      reserve(size);
-    }
-
-    buffer = new char[size + 1];
-    for(i = z = 0; i < ssl;) {
-      if(i <= ssl - ksl) {
-        if(!memcmp(data + i, key, ksl)) {
-          memcpy(buffer + z, token, tsl);
-          z += tsl;
-          i += ksl;
-        } else buffer[z++] = data[i++];
-      } else buffer[z++] = data[i++];
-    }
-    buffer[z] = 0;
-
-    assign(buffer);
-    delete[] buffer;
-  }
-
-  return *this;
-}
-
-string& string::qreplace(const char *key, const char *token) {
-  int i, l, z, ksl = strlen(key), tsl = strlen(token), ssl = length();
-  unsigned int replace_count = 0, size = ssl;
-  uint8_t x;
-  char *buffer;
-
-  if(ksl <= ssl) {
-    if(tsl > ksl) {
-      for(i = 0; i <= ssl - ksl;) {
-        x = data[i];
-        if(x == '\"' || x == '\'') {
-          l = i;
-          i++;
-          while(data[i++] != x) {
-            if(i == ssl) {
-              i = l;
-              break;
-            }
-          }
-        }
-        if(!memcmp(data + i, key, ksl)) {
-          replace_count++;
-          i += ksl;
-        } else i++;
-      }
-      size = ssl + ((tsl - ksl) * replace_count);
-      reserve(size);
-    }
-
-    buffer = new char[size + 1];
-    for(i = z = 0; i < ssl;) {
-      x = data[i];
-      if(x == '\"' || x == '\'') {
-        l = i++;
-        while(data[i] != x && i < ssl)i++;
-        if(i >= ssl)i = l;
-        else {
-          memcpy(buffer + z, data + l, i - l);
-          z += i - l;
-        }
-      }
-      if(i <= ssl - ksl) {
-        if(!memcmp(data + i, key, ksl)) {
-          memcpy(buffer + z, token, tsl);
-          z += tsl;
-          i += ksl;
-          replace_count++;
-        } else buffer[z++] = data[i++];
-      } else buffer[z++] = data[i++];
-    }
-    buffer[z] = 0;
-
-    assign(buffer);
-    delete[] buffer;
-  }
-
-  return *this;
-}
-
-};
-
-#endif

bsnes/nall/string/split.hpp

@@ -1,56 +0,0 @@
-#ifndef NALL_STRING_SPLIT_HPP
-#define NALL_STRING_SPLIT_HPP
-
-namespace nall {
-
-void lstring::split(const char *key, const char *src, unsigned limit) {
-  reset();
-
-  int ssl = strlen(src), ksl = strlen(key);
-  int lp = 0, split_count = 0;
-
-  for(int i = 0; i <= ssl - ksl;) {
-    if(!memcmp(src + i, key, ksl)) {
-      strlcpy(operator[](split_count++), src + lp, i - lp + 1);
-      i += ksl;
-      lp = i;
-      if(!--limit) break;
-    } else i++;
-  }
-
-  operator[](split_count++) = src + lp;
-}
-
-void lstring::qsplit(const char *key, const char *src, unsigned limit) {
-  reset();
-
-  int ssl = strlen(src), ksl = strlen(key);
-  int lp = 0, split_count = 0;
-
-  for(int i = 0; i <= ssl - ksl;) {
-    uint8_t x = src[i];
-
-    if(x == '\"' || x == '\'') {
-      int z = i++;                        //skip opening quote
-      while(i < ssl && src[i] != x) i++;
-      if(i >= ssl) i = z;                 //failed match, rewind i
-      else {
-        i++;                              //skip closing quote
-        continue;                         //restart in case next char is also a quote
-      }
-    }
-
-    if(!memcmp(src + i, key, ksl)) {
-      strlcpy(operator[](split_count++), src + lp, i - lp + 1);
-      i += ksl;
-      lp = i;
-      if(!--limit) break;
-    } else i++;
-  }
-
-  operator[](split_count++) = src + lp;
-}
-
-};
-
-#endif

bsnes/nall/string/strl.hpp

@@ -1,52 +0,0 @@
-#ifndef NALL_STRING_STRL_HPP
-#define NALL_STRING_STRL_HPP
-
-namespace nall {
-
-//strlcpy, strlcat based on OpenBSD implementation by Todd C. Miller
-
-//return = strlen(src)
-unsigned strlcpy(char *dest, const char *src, unsigned length) {
-  char *d = dest;
-  const char *s = src;
-  unsigned n = length;
-
-  if(n) {
-    while(--n && (*d++ = *s++)); //copy as many bytes as possible, or until null terminator reached
-  }
-
-  if(!n) {
-    if(length) *d = 0;
-    while(*s++); //traverse rest of s, so that s - src == strlen(src)
-  }
-
-  return (s - src - 1); //return length of copied string, sans null terminator
-}
-
-//return = strlen(src) + min(length, strlen(dest))
-unsigned strlcat(char *dest, const char *src, unsigned length) {
-  char *d = dest;
-  const char *s = src;
-  unsigned n = length;
-
-  while(n-- && *d) d++; //find end of dest
-  unsigned dlength = d - dest;
-  n = length - dlength; //subtract length of dest from maximum string length
-
-  if(!n) return dlength + strlen(s);
-
-  while(*s) {
-    if(n != 1) {
-      *d++ = *s;
-      n--;
-    }
-    s++;
-  }
-  *d = 0;
-
-  return dlength + (s - src); //return length of resulting string, sans null terminator
-}
-
-}
-
-#endif

bsnes/nall/string/strpos.hpp

@@ -1,41 +0,0 @@
-#ifndef NALL_STRING_STRPOS_HPP
-#define NALL_STRING_STRPOS_HPP
-
-//usage example:
-//if(auto pos = strpos(str, key)) print(pos(), "\n");
-//prints position of key within str, only if it is found
-
-namespace nall {
-
-inline optional<unsigned> strpos(const char *str, const char *key) {
-  unsigned ssl = strlen(str), ksl = strlen(key);
-  if(ksl > ssl) return { false, 0 };
-
-  for(unsigned i = 0; i <= ssl - ksl; i++) {
-    if(!memcmp(str + i, key, ksl)) return { true, i };
-  }
-
-  return { false, 0 };
-}
-
-inline optional<unsigned> qstrpos(const char *str, const char *key) {
-  unsigned ssl = strlen(str), ksl = strlen(key);
-  if(ksl > ssl) return { false, 0 };
-
-  for(unsigned i = 0; i <= ssl - ksl;) {
-    uint8_t x = str[i];
-    if(x == '\"' || x == '\'') {
-      uint8_t z = i++;
-      while(str[i] != x && i < ssl) i++;
-      if(i >= ssl) i = z;
-    }
-    if(!memcmp(str + i, key, ksl)) return { true, i };
-    i++;
-  }
-
-  return { false, 0 };
-}
-
-}
-
-#endif

bsnes/nall/string/trim.hpp

@@ -1,61 +0,0 @@
-#ifndef NALL_STRING_TRIM_HPP
-#define NALL_STRING_TRIM_HPP
-
-namespace nall {
-
-char* ltrim(char *str, const char *key) {
-  if(!key || !*key) return str;
-  while(strbegin(str, key)) {
-    char *dest = str, *src = str + strlen(key);
-    while(true) {
-      *dest = *src++;
-      if(!*dest) break;
-      dest++;
-    }
-  }
-  return str;
-}
-
-char* rtrim(char *str, const char *key) {
-  if(!key || !*key) return str;
-  while(strend(str, key)) str[strlen(str) - strlen(key)] = 0;
-  return str;
-}
-
-char* trim(char *str, const char *key) {
-  return ltrim(rtrim(str, key), key);
-}
-
-char* ltrim_once(char *str, const char *key) {
-  if(!key || !*key) return str;
-  if(strbegin(str, key)) {
-    char *dest = str, *src = str + strlen(key);
-    while(true) {
-      *dest = *src++;
-      if(!*dest) break;
-      dest++;
-    }
-  }
-  return str;
-}
-
-char* rtrim_once(char *str, const char *key) {
-  if(!key || !*key) return str;
-  if(strend(str, key)) str[strlen(str) - strlen(key)] = 0;
-  return str;
-}
-
-char* trim_once(char *str, const char *key) {
-  return ltrim_once(rtrim_once(str, key), key);
-}
-
-string& string::ltrim(const char *key) { nall::ltrim(data, key); return *this; }
-string& string::rtrim(const char *key) { nall::rtrim(data, key); return *this; }
-string& string::trim (const char *key) { nall::trim (data, key); return *this; }
-string& string::ltrim_once(const char *key) { nall::ltrim_once(data, key); return *this; }
-string& string::rtrim_once(const char *key) { nall::rtrim_once(data, key); return *this; }
-string& string::trim_once (const char *key) { nall::trim_once (data, key); return *this; }
-
-}
-
-#endif

bsnes/nall/string/utility.hpp

@@ -1,157 +0,0 @@
-#ifndef NALL_STRING_UTILITY_HPP
-#define NALL_STRING_UTILITY_HPP
-
-namespace nall {
-
-unsigned strlcpy(string &dest, const char *src, unsigned length) {
-  dest.reserve(length);
-  return strlcpy(dest(), src, length);
-}
-
-unsigned strlcat(string &dest, const char *src, unsigned length) {
-  dest.reserve(length);
-  return strlcat(dest(), src, length);
-}
-
-string substr(const char *src, unsigned start, unsigned length) {
-  string dest;
-  if(length == 0) {
-    //copy entire string
-    dest = src + start;
-  } else {
-    //copy partial string
-    strlcpy(dest, src + start, length + 1);
-  }
-  return dest;
-}
-
-/* arithmetic <> string */
-
-template<unsigned length, char padding> string strhex(uintmax_t value) {
-  string output;
-  unsigned offset = 0;
-
-  //render string backwards, as we do not know its length yet
-  do {
-    unsigned n = value & 15;
-    output[offset++] = n < 10 ? '0' + n : 'a' + n - 10;
-    value >>= 4;
-  } while(value);
-
-  while(offset < length) output[offset++] = padding;
-  output[offset--] = 0;
-
-  //reverse the string in-place
-  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
-    char temp = output[i];
-    output[i] = output[offset - i];
-    output[offset - i] = temp;
-  }
-
-  return output;
-}
-
-template<unsigned length, char padding> string strsigned(intmax_t value) {
-  string output;
-  unsigned offset = 0;
-
-  bool negative = value < 0;
-  if(negative) value = abs(value);
-
-  do {
-    unsigned n = value % 10;
-    output[offset++] = '0' + n;
-    value /= 10;
-  } while(value);
-
-  while(offset < length) output[offset++] = padding;
-  if(negative) output[offset++] = '-';
-  output[offset--] = 0;
-
-  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
-    char temp = output[i];
-    output[i] = output[offset - i];
-    output[offset - i] = temp;
-  }
-
-  return output;
-}
-
-template<unsigned length, char padding> string strunsigned(uintmax_t value) {
-  string output;
-  unsigned offset = 0;
-
-  do {
-    unsigned n = value % 10;
-    output[offset++] = '0' + n;
-    value /= 10;
-  } while(value);
-
-  while(offset < length) output[offset++] = padding;
-  output[offset--] = 0;
-
-  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
-    char temp = output[i];
-    output[i] = output[offset - i];
-    output[offset - i] = temp;
-  }
-
-  return output;
-}
-
-template<unsigned length, char padding> string strbin(uintmax_t value) {
-  string output;
-  unsigned offset = 0;
-
-  do {
-    unsigned n = value & 1;
-    output[offset++] = '0' + n;
-    value >>= 1;
-  } while(value);
-
-  while(offset < length) output[offset++] = padding;
-  output[offset--] = 0;
-
-  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
-    char temp = output[i];
-    output[i] = output[offset - i];
-    output[offset - i] = temp;
-  }
-
-  return output;
-}
-
-//using sprintf is certainly not the most ideal method to convert
-//a double to a string ... but attempting to parse a double by
-//hand, digit-by-digit, results in subtle rounding errors.
-unsigned strdouble(char *str, double value) {
-  char buffer[256];
-  sprintf(buffer, "%f", value);
-
-  //remove excess 0's in fraction (2.500000 -> 2.5)
-  for(char *p = buffer; *p; p++) {
-    if(*p == '.') {
-      char *p = buffer + strlen(buffer) - 1;
-      while(*p == '0') {
-        if(*(p - 1) != '.') *p = 0;  //... but not for eg 1.0 -> 1.
-        p--;
-      }
-      break;
-    }
-  }
-
-  unsigned length = strlen(buffer);
-  if(str) strcpy(str, buffer);
-  return length + 1;
-}
-
-string strdouble(double value) {
-  string temp;
-  temp.reserve(strdouble(0, value));
-  strdouble(temp(), value);
-  return temp;
-}
-
-}
-
-#endif

bsnes/nall/string/variadic.hpp

@@ -1,12 +0,0 @@
-#ifndef NALL_STRING_VARIADIC_HPP
-#define NALL_STRING_VARIADIC_HPP
-
-namespace nall {
-
-template<typename... Args> inline void print(Args&&... args) {
-  printf("%s", (const char*)string(std::forward<Args>(args)...));
-}
-
-}
-
-#endif