Update to v099r14 release.

byuu says:

Changelog:
- (u)int(max,ptr) abbreviations removed; use _t suffix now [didn't feel
  like they were contributing enough to be worth it]
- cleaned up nall::integer,natural,real functionality
  - toInteger, toNatural, toReal for parsing strings to numbers
  - fromInteger, fromNatural, fromReal for creating strings from numbers
  - (string,Markup::Node,SQL-based-classes)::(integer,natural,real)
    left unchanged
  - template<typename T> numeral(T value, long padding, char padchar)
    -> string for print() formatting
    - deduces integer,natural,real based on T ... cast the value if you
      want to override
    - there still exists binary,octal,hex,pointer for explicit print()
      formatting
- lstring -> string_vector [but using lstring = string_vector; is
  declared]
  - would be nice to remove the using lstring eventually ... but that'd
    probably require 10,000 lines of changes >_>
- format -> string_format [no using here; format was too ambiguous]
- using integer = Integer<sizeof(int)*8>; and using natural =
  Natural<sizeof(uint)*8>; declared
  - for consistency with boolean. These three are meant for creating
    zero-initialized values implicitly (various uses)
- R65816::io() -> idle() and SPC700::io() -> idle() [more clear; frees
  up struct IO {} io; naming]
- SFC CPU, PPU, SMP use struct IO {} io; over struct (Status,Registers) {}
  (status,registers); now
  - still some CPU::Status status values ... they didn't really fit into
    IO functionality ... will have to think about this more
- SFC CPU, PPU, SMP now use step() exclusively instead of addClocks()
  calling into step()
- SFC CPU joypad1_bits, joypad2_bits were unused; killed them
- SFC PPU CGRAM moved into PPU::Screen; since nothing else uses it
- SFC PPU OAM moved into PPU::Object; since nothing else uses it
  - the raw uint8[544] array is gone. OAM::read() constructs values from
    the OAM::Object[512] table now
  - this avoids having to determine how we want to sub-divide the two
    OAM memory sections
  - this also eliminates the OAM::synchronize() functionality
- probably more I'm forgetting

The FPS fluctuations are driving me insane. This WIP went from 128fps to
137fps. Settled on 133.5fps for the final build. But nothing I changed
should have affected performance at all. This level of fluctuation makes
it damn near impossible to know whether I'm speeding things up or slowing
things down with changes.

nall/string/cast.hpp

@@ -33,42 +33,42 @@ template<> struct stringify<char> {
 //signed integers
 
 template<> struct stringify<signed char> {
-  stringify(signed char source) { integer(_data, source); }
+  stringify(signed char source) { fromInteger(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[2 + sizeof(signed char) * 3];
 };
 
 template<> struct stringify<signed short> {
-  stringify(signed short source) { integer(_data, source); }
+  stringify(signed short source) { fromInteger(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[2 + sizeof(signed short) * 3];
 };
 
 template<> struct stringify<signed int> {
-  stringify(signed int source) { integer(_data, source); }
+  stringify(signed int source) { fromInteger(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[2 + sizeof(signed int) * 3];
 };
 
 template<> struct stringify<signed long> {
-  stringify(signed long source) { integer(_data, source); }
+  stringify(signed long source) { fromInteger(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[2 + sizeof(signed long) * 3];
 };
 
 template<> struct stringify<signed long long> {
-  stringify(signed long long source) { integer(_data, source); }
+  stringify(signed long long source) { fromInteger(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[2 + sizeof(signed long long) * 3];
 };
 
 template<uint Bits> struct stringify<Integer<Bits>> {
-  stringify(Integer<Bits> source) { integer(_data, source); }
+  stringify(Integer<Bits> source) { fromInteger(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[2 + sizeof(int64_t) * 3];
@@ -77,42 +77,42 @@ template<uint Bits> struct stringify<Integer<Bits>> {
 //unsigned integers
 
 template<> struct stringify<unsigned char> {
-  stringify(unsigned char source) { natural(_data, source); }
+  stringify(unsigned char source) { fromNatural(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[1 + sizeof(unsigned char) * 3];
 };
 
 template<> struct stringify<unsigned short> {
-  stringify(unsigned short source) { natural(_data, source); }
+  stringify(unsigned short source) { fromNatural(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[1 + sizeof(unsigned short) * 3];
 };
 
 template<> struct stringify<unsigned int> {
-  stringify(unsigned int source) { natural(_data, source); }
+  stringify(unsigned int source) { fromNatural(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[1 + sizeof(unsigned int) * 3];
 };
 
 template<> struct stringify<unsigned long> {
-  stringify(unsigned long source) { natural(_data, source); }
+  stringify(unsigned long source) { fromNatural(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[1 + sizeof(unsigned long) * 3];
 };
 
 template<> struct stringify<unsigned long long> {
-  stringify(unsigned long long source) { natural(_data, source); }
+  stringify(unsigned long long source) { fromNatural(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[1 + sizeof(unsigned long long) * 3];
 };
 
 template<uint Bits> struct stringify<Natural<Bits>> {
-  stringify(Natural<Bits> source) { natural(_data, source); }
+  stringify(Natural<Bits> source) { fromNatural(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[1 + sizeof(uint64_t) * 3];
@@ -121,28 +121,28 @@ template<uint Bits> struct stringify<Natural<Bits>> {
 //floating-point
 
 template<> struct stringify<float> {
-  stringify(float source) { real(_data, source); }
+  stringify(float source) { fromReal(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[256];
 };
 
 template<> struct stringify<double> {
-  stringify(double source) { real(_data, source); }
+  stringify(double source) { fromReal(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[256];
 };
 
 template<> struct stringify<long double> {
-  stringify(long double source) { real(_data, source); }
+  stringify(long double source) { fromReal(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[256];
 };
 
 template<uint Bits> struct stringify<Real<Bits>> {
-  stringify(Real<Bits> source) { real(_data, source); }
+  stringify(Real<Bits> source) { fromReal(_data, source); }
   auto data() const -> const char* { return _data; }
   auto size() const -> uint { return strlen(_data); }
   char _data[256];