1 files changed, 118 insertions, 12 deletions

diff --git a/src/float.cpp b/src/float.cpp
index 879d74b..f1e9ced 100644
--- a/src/float.cpp
+++ b/src/float.cpp
@@ -2,7 +2,10 @@
 #include "gats/integer.h"
 
 #include <bu/formatter.h>
+#include <math.h>
 
+#include <bu/sio.h>
+using namespace Bu;
 Gats::Float::Float() :
         fVal( 0.0 )
 {
@@ -19,25 +22,128 @@ Gats::Float::~Float()
 
 void Gats::Float::write( Bu::Stream &rOut ) const
 {
-        if( sWriteCache.isEmpty() )
+        if( fVal == 0.0 )
         {
-                char buf[50];
+                if( signbit( fVal ) )
+                        rOut.write("FZ", 2 );
+                else
+                        rOut.write("Fz", 2 );
+        }
+        else if( !isfinite( fVal ) )
+        {
+                if( isnan( fVal ) )
+                {
+                        if( signbit( fVal ) )
+                                rOut.write("FN", 2 );
+                        else
+                                rOut.write("Fn", 2 );
+                }
+                else
+                {
+                        if( signbit( fVal ) )
+                                rOut.write("FI", 2 );
+                        else
+                                rOut.write("Fi", 2 );
+                }
+        }
+        else
+        {
+                rOut.write("f", 1 );
+                double d = fVal;
+                bool bNeg = false;
+                int64_t iScale=0;
+                if( signbit( d ) )
+                {
+                        bNeg = true;
+                        d = -d;
+                }
 
-                int iSize = snprintf( buf, 50, "%la", fVal );
-                sWriteCache.set( buf, iSize );
+                if( d == 0.0 )
+                {
+                }
+                else if( d < 1.0 )
+                {
+                        while( d < 1.0 )
+                        {
+                                d *= 256.0;
+                                iScale--;
+                        }
+                }
+                else
+                {
+                        while( d >= 256.0 )
+                        {
+                                d *= 0x1p-8; // That's .00390625, or 1/256
+                                iScale++;
+                        }
+                }
+                Bu::String s;
+                s += (uint8_t)(d);
+                d -= (int)d;
+                for( int j = 0; j < 150 && d; j++ )
+                {
+                        d = d*256.0;
+                        s += (uint8_t)d;
+                        d -= (int)d;
+                }
+                Gats::Integer::writePackedInt( rOut, bNeg?-s.getSize():s.getSize() );
+                rOut.write( s.getStr(), s.getSize() );
+                Gats::Integer::writePackedInt( rOut, iScale );
         }
-        rOut.write("f", 1 );
-        Gats::Integer::writePackedInt( rOut, sWriteCache.getSize() );
-        rOut.write( sWriteCache.getStr(), sWriteCache.getSize() );
 }
 
 void Gats::Float::read( Bu::Stream &rIn, char cType )
 {
-        int iSize;
-        Gats::Integer::readPackedInt( rIn, iSize );
-        char buf[50];
-        buf[rIn.read( buf, iSize )] = '\0';
-        sscanf( buf, "%la", &fVal );
+        if( cType == 'F' )
+        {
+                char buf;
+                rIn.read( &buf, 1 );
+                switch( buf )
+                {
+                        case 'N': fVal = -NAN;          break;
+                        case 'n': fVal = NAN;           break;
+                        case 'I': fVal = -INFINITY;     break;
+                        case 'i': fVal = INFINITY;      break;
+                        case 'Z': fVal = -0.0;          break;
+                        case 'z': fVal = 0.0;           break;
+                }
+        }
+        else if( cType == 'f' )
+        {
+                int64_t iStr;
+                Gats::Integer::readPackedInt( rIn, iStr );
+                bool bNeg = false;
+                if( iStr < 0 )
+                {
+                        bNeg = true;
+                        iStr = -iStr;
+                }
+                Bu::String s( iStr );
+                rIn.read( s.getStr(), iStr );
+                fVal = 0.0;
+                for( int j = iStr-1; j > 0; j-- )
+                {
+                        fVal = (fVal+(uint8_t)s[j])*0x1p-8;
+                }
+                fVal += (uint8_t)s[0];
+                int64_t iScale;
+                Gats::Integer::readPackedInt( rIn, iScale );
+                if( iScale < 0 )
+                {
+                        for( int64_t j = 0; j > iScale; j-- )
+                        {
+                                fVal *= 0x1p-8;
+                        }
+                }
+                else
+                {
+                        for( int64_t j = 0; j < iScale; j++ )
+                        {
+                                fVal *= 256.0;
+                        }
+                }
+                if( bNeg ) fVal = -fVal;
+        }
 }
 
 Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Float &flt )