1 files changed, 130 insertions, 0 deletions

diff --git a/c++-libbu++/src/float.cpp b/c++-libbu++/src/float.cpp
new file mode 100644
index 0000000..c01d824
--- /dev/null
+++ b/c++-libbu++/src/float.cpp
@@ -0,0 +1,130 @@
+#include "gats/float.h"
+#include "gats/integer.h"
+
+#include <bu/formatter.h>
+#include <math.h>
+
+#include <bu/sio.h>
+using namespace Bu;
+Gats::Float::Float() :
+        fVal( 0.0 )
+{
+}
+
+Gats::Float::Float( double f ) :
+        fVal( f )
+{
+}
+
+Gats::Float::~Float()
+{
+}
+
+Gats::Object *Gats::Float::clone() const
+{
+        return new Gats::Float( fVal );
+}
+
+void Gats::Float::write( Bu::Stream &rOut ) const
+{
+        if( fVal == 0.0 )
+        {
+                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;
+                }
+
+                iScale = log( d ) / 0x1.62e42fefa39efp+2; // log( 256.0 )
+                if( iScale < 0 ) iScale--;
+                d /= pow( 256.0, 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 );
+        }
+}
+
+void Gats::Float::read( Bu::Stream &rIn, char cType )
+{
+        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 );
+                fVal *= pow( 256.0, iScale );
+                if( bNeg ) fVal = -fVal;
+        }
+}
+
+Bu::Formatter &operator<<( Bu::Formatter &f, const Gats::Float &flt )
+{
+        return f << "(float) " << flt.getValue();
+}
+