Update to v106r2 release.

byuu says:

Changelog:

  - Super Famicom: added support for loading manifests without embedded
    mapping information¹
  - genius: initial commit
  - various Makefile cleanups

¹: so the idea here is to try and aim for a stable manifest format,
and to allow direct transposition of icarus/genius database entries into
manifest files. The exact mechanics of how this is going to work is
currently in flux, but we'll get there.

For right now, `Super Famicom.sys` gains `boards.bml`, which is the raw
database from my board-editor tool, and higan itself tries to load
`boards.bml`, match an entry to game/board from the game's `manifest.bml`
file, and then transform it into the format currently used by higan. It
does this only when the game's `manifest.bml` file lacks a board node.
When such a board node exists, it works as previous versions of higan
did.

The only incompatible change right now is information/title is now
located at game/label. I may transition window title display to just use
the filenames instead.

Longer term, some thought is going to need to go into the format of the
`boards.bml` database itself, and at which point in the process I should
be transforming things.

Give it time, we'll refine this into something nicer.

nall/encode/base.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <nall/arithmetic.hpp>
+
+namespace nall { namespace Encode {
+
+template<uint Bits, typename T> inline auto Base(T value) -> string {
+  static const string format =
+    Bits ==  2 ? "01"
+  : Bits ==  8 ? "01234567"
+  : Bits == 10 ? "0123456789"
+  : Bits == 16 ? "0123456789abcdef"
+  : Bits == 32 ? "0123456789abcdefghijklmnopqrstuv"
+  : Bits == 34 ? "023456789abcdefghijkmnopqrstuvwxyz"  //1l
+  : Bits == 36 ? "0123456789abcdefghijklmnopqrstuvwxyz"
+  : Bits == 57 ? "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"  //01IOl
+  : Bits == 62 ? "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+  : Bits == 64 ? "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz{}"
+  : Bits == 85 ? "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%()+,-.:;=@[]^_`{|}~"  //\ "&'*/<>?
+  : "";
+  static const uint size = ceil(sizeof(T) * 8 / log2(Bits));
+
+  string result;
+  result.resize(size);
+  char* data = result.get() + size;
+  for(auto byte : result) {
+    *--data = format[value % Bits];
+    value /= Bits;
+  }
+  return result;
+}
+
+}}

nall/encode/base57.hpp

@@ -1,19 +0,0 @@
-#pragma once
-
-#include <nall/arithmetic.hpp>
-
-namespace nall { namespace Encode {
-
-template<typename T> inline auto Base57(T value) -> string {
-  static const char lookup[] = "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-  static const uint size = ceil(sizeof(T) * 8 / log2(57));
-
-  string result;
-  for(auto n : range(size)) {
-    result.append(lookup[value % 57]);
-    value /= 57;
-  }
-  return result;
-}
-
-}}

nall/encode/base64.hpp

@@ -2,14 +2,15 @@
 
 namespace nall { namespace Encode {
 
-inline auto Base64(const void* vdata, unsigned size, const string& format = "MIME") -> string {
-  auto data = (const uint8_t*)vdata;
-  vector<uint8_t> result;
-
-  char lookup[65];
-  for(unsigned n = 0; n < 26; n++) lookup[ 0 + n] = 'A' + n;
-  for(unsigned n = 0; n < 26; n++) lookup[26 + n] = 'a' + n;
-  for(unsigned n = 0; n < 10; n++) lookup[52 + n] = '0' + n;
+inline auto Base64(const void* vdata, uint size, const string& format = "MIME") -> string {
+  static bool initialized = false;
+  static char lookup[65] = {0};
+  if(!initialized) {
+    initialized = true;
+    for(uint n : range(26)) lookup[n +  0] = 'A' + n;
+    for(uint n : range(26)) lookup[n + 26] = 'a' + n;
+    for(uint n : range(10)) lookup[n + 52] = '0' + n;
+  }
 
   if(format == "MIME") {
     lookup[62] = '+';
@@ -21,37 +22,36 @@ inline auto Base64(const void* vdata, unsigned size, const string& format = "MIM
     lookup[64] = 0;
   } else return "";
 
-  unsigned overflow = (3 - (size % 3)) % 3;  //bytes to round to nearest multiple of 3
+  auto data = (const uint8_t*)vdata;
+  uint overflow = (3 - (size % 3)) % 3;  //bytes to round to nearest multiple of 3
+  string result;
   uint8_t buffer;
-
-  for(unsigned i = 0; i < size; i++) {
-    switch(i % 3) {
+  for(uint n : range(size)) {
+    switch(n % 3) {
     case 0:
-      buffer = data[i] >> 2;
-      result.append(lookup[buffer]);
-      buffer = (data[i] & 3) << 4;
+      buffer = data[n] >> 2;
       result.append(lookup[buffer]);
+      buffer = (data[n] & 3) << 4;
       break;
 
     case 1:
-      buffer |= data[i] >> 4;
-      result.right() = lookup[buffer];
-      buffer = (data[i] & 15) << 2;
+      buffer |= data[n] >> 4;
       result.append(lookup[buffer]);
+      buffer = (data[n] & 15) << 2;
       break;
 
     case 2:
-      buffer |= data[i] >> 6;
-      result.right() = lookup[buffer];
-      buffer = (data[i] & 63);
+      buffer |= data[n] >> 6;
+      result.append(lookup[buffer]);
+      buffer = (data[n] & 63);
       result.append(lookup[buffer]);
       break;
     }
   }
 
+  if(overflow) result.append(lookup[buffer]);
   if(lookup[64]) {
-    if(overflow >= 1) result.append(lookup[64]);
-    if(overflow >= 2) result.append(lookup[64]);
+    while(result.size() % 4) result.append(lookup[64]);
   }
 
   return result;