Converted tabs to spaces with tabconv.

150 files changed, 18694 insertions, 18694 deletions

diff --git a/src/stable/archival.cpp b/src/stable/archival.cpp
index 5e6e612..9ba10f2 100644
--- a/src/stable/archival.cpp
+++ b/src/stable/archival.cpp
@@ -17,19 +17,19 @@ Bu::Archival::~Archival()
 
 Bu::ArchiveBase &Bu::operator<<(Bu::ArchiveBase &s, const Bu::Archival &p)
 {
-        const_cast<Bu::Archival &>(p).archive( s );
-        return s;
+    const_cast<Bu::Archival &>(p).archive( s );
+    return s;
 }
 
 Bu::ArchiveBase &Bu::operator<<(Bu::ArchiveBase &s, Bu::Archival &p)
 {
-        p.archive( s );
-        return s;
+    p.archive( s );
+    return s;
 }
 
 Bu::ArchiveBase &Bu::operator>>(Bu::ArchiveBase &s, Bu::Archival &p)
 {
-        p.archive( s );
-        return s;
+    p.archive( s );
+    return s;
 }
 
diff --git a/src/stable/archival.h b/src/stable/archival.h
index 664bc98..78faffb 100644
--- a/src/stable/archival.h
+++ b/src/stable/archival.h
@@ -12,40 +12,40 @@
 
 namespace Bu
 {
-        /**
-         * The base class for any class you want to archive.  Simply include this as
-         * a base class, implement the purely virtual archive function and you've
-         * got an easily archiveable class.
-         *
-         * Archival: "of or pertaining to archives or valuable records; contained
+    /**
+     * The base class for any class you want to archive.  Simply include this as
+     * a base class, implement the purely virtual archive function and you've
+     * got an easily archiveable class.
+     *
+     * Archival: "of or pertaining to archives or valuable records; contained
          * in or comprising such archives or records."
-         */
-        class Archival
-        {
-        public:
-                /**
-                 * Does nothing, here for completeness.
-                 */
-                Archival();
-
-                /**
-                 * Here to ensure the deconstructor is virtual.
-                 */
-                virtual ~Archival();
-
-                /**
-                 * This is the main workhorse of the archive system, just override and
-                 * you've got a archiveable class.  A reference to the Archive
-                 * used is passed in as your only parameter, query it to discover if
-                 * you are loading or saving.
-                 * @param ar A reference to the Archive object to use.
-                 */
-                virtual void archive( class ArchiveBase &ar )=0;
-        };
-
-        ArchiveBase &operator<<(ArchiveBase &, const class Bu::Archival &);
-        ArchiveBase &operator<<(ArchiveBase &, class Bu::Archival &);
-        ArchiveBase &operator>>(ArchiveBase &, class Bu::Archival &);
+     */
+    class Archival
+    {
+    public:
+        /**
+         * Does nothing, here for completeness.
+         */
+        Archival();
+
+        /**
+         * Here to ensure the deconstructor is virtual.
+         */
+        virtual ~Archival();
+
+        /**
+         * This is the main workhorse of the archive system, just override and
+         * you've got a archiveable class.  A reference to the Archive
+         * used is passed in as your only parameter, query it to discover if
+         * you are loading or saving.
+         * @param ar A reference to the Archive object to use.
+         */
+        virtual void archive( class ArchiveBase &ar )=0;
+    };
+
+    ArchiveBase &operator<<(ArchiveBase &, const class Bu::Archival &);
+    ArchiveBase &operator<<(ArchiveBase &, class Bu::Archival &);
+    ArchiveBase &operator>>(ArchiveBase &, class Bu::Archival &);
 
 }
 
diff --git a/src/stable/archive.cpp b/src/stable/archive.cpp
index 13480e1..3769e0e 100644
--- a/src/stable/archive.cpp
+++ b/src/stable/archive.cpp
@@ -12,9 +12,9 @@
 #include "bu/sio.h"
 
 Bu::Archive::Archive( Stream &rStream, bool bLoading ) :
-        bLoading( bLoading ),
-        rStream( rStream ),
-        nNextID( 1 )
+    bLoading( bLoading ),
+    rStream( rStream ),
+    nNextID( 1 )
 {
 }
 
@@ -24,66 +24,66 @@ Bu::Archive::~Archive()
 
 void Bu::Archive::write( const void *pData, size_t nSize )
 {
-        if( nSize == 0 || pData == NULL )
-                return;
+    if( nSize == 0 || pData == NULL )
+        return;
 
-        rStream.write( (const char *)pData, nSize );
+    rStream.write( (const char *)pData, nSize );
 }
 
 void Bu::Archive::read( void *pData, size_t nSize )
 {
-        if( nSize == 0 || pData == NULL )
-                return;
+    if( nSize == 0 || pData == NULL )
+        return;
 
-        if( (size_t)rStream.read( (char *)pData, nSize ) < nSize )
-                throw Bu::ExceptionBase("Insufficient data to unarchive object.");
+    if( (size_t)rStream.read( (char *)pData, nSize ) < nSize )
+        throw Bu::ExceptionBase("Insufficient data to unarchive object.");
 }
 
 void Bu::Archive::close()
 {
-        rStream.close();
+    rStream.close();
 }
 
 bool Bu::Archive::isLoading()
 {
-        return bLoading;
+    return bLoading;
 }
 
 uint32_t Bu::Archive::getID( const void *ptr )
 {
-        if( hPtrID.has( (ptrdiff_t)ptr ) )
-                return hPtrID.get( (ptrdiff_t)ptr );
-        hPtrID.insert( (ptrdiff_t)ptr, nNextID );
-        return nNextID++;
+    if( hPtrID.has( (ptrdiff_t)ptr ) )
+        return hPtrID.get( (ptrdiff_t)ptr );
+    hPtrID.insert( (ptrdiff_t)ptr, nNextID );
+    return nNextID++;
 }
 
 void Bu::Archive::assocPtrID( void **ptr, uint32_t id )
 {
-        if( hPtrID.has( id ) )
-        {
-                *ptr = (void *)hPtrID.get( id );
-                return;
-        }
-
-        if( !hPtrDest.has( id ) )
-                hPtrDest.insert( id, List<void **>() );
-                        
-        hPtrDest[id].getValue().append( ptr );
+    if( hPtrID.has( id ) )
+    {
+        *ptr = (void *)hPtrID.get( id );
+        return;
+    }
+
+    if( !hPtrDest.has( id ) )
+        hPtrDest.insert( id, List<void **>() );
+            
+    hPtrDest[id].getValue().append( ptr );
 }
 
 void Bu::Archive::readID( const void *ptr, uint32_t id )
 {
-        hPtrID.insert( id, (ptrdiff_t)ptr );
-
-        if( hPtrDest.has( id ) )
-        {
-                Bu::List<void **> &l = hPtrDest.get( id );
-                for( Bu::List<void **>::iterator i = l.begin(); i != l.end(); i++ )
-                {
-                        *(*i) = (void *)ptr;
-                }
-
-                hPtrDest.erase( id );
-        }
+    hPtrID.insert( id, (ptrdiff_t)ptr );
+
+    if( hPtrDest.has( id ) )
+    {
+        Bu::List<void **> &l = hPtrDest.get( id );
+        for( Bu::List<void **>::iterator i = l.begin(); i != l.end(); i++ )
+        {
+            *(*i) = (void *)ptr;
+        }
+
+        hPtrDest.erase( id );
+    }
 }
 
diff --git a/src/stable/archive.h b/src/stable/archive.h
index 9716bb1..f98402d 100644
--- a/src/stable/archive.h
+++ b/src/stable/archive.h
@@ -16,123 +16,123 @@
 
 namespace Bu
 {
-        class Archival;
-        class Stream;
+    class Archival;
+    class Stream;
 
-        /**
-         * Provides a framework for serialization of objects and primitives.  The
-         * archive will handle any basic primitive, a few special types, like char *
-         * strings, as well as STL classes and anything that inherits from the
-         * Archival class.  Each Archive operates on a Stream, so you can send the
-         * data using an Archive almost anywhere.
-         *
-         * In order to use an Archive to store something to a file, try something
-         * like:
-         *@code
+    /**
+     * Provides a framework for serialization of objects and primitives.  The
+     * archive will handle any basic primitive, a few special types, like char *
+     * strings, as well as STL classes and anything that inherits from the
+     * Archival class.  Each Archive operates on a Stream, so you can send the
+     * data using an Archive almost anywhere.
+     *
+     * In order to use an Archive to store something to a file, try something
+     * like:
+     *@code
      * File sOut("output", "wb"); // This is a stream subclass
-         * Archive ar( sOut, Archive::save );
-         * ar << myClass;
-         @endcode
-         * In this example myClass is any class that inherits from Archival.  When
-         * the storage operator is called, the Archival::archive() function in the
-         * myClass object is called with a reference to the Archive.  This can be
-         * handled in one of two ways:
-         *@code
-         * void MyClass::archive( Archive &ar )
-         * {
-         *      ar && sName && nAge && sJob;
-         * }
-         @endcode
-         * Here we don't worry about weather we're loading or saving by using the
-         * smart && operator.  This allows us to write very consistent, very simple
-         * archive functions that really do a lot of work.  If we wanted to do
-         * something different in the case of loading or saving we would do:
-         *@code
-         * void MyClass::archive( Archive &ar )
-         * {
-         *      if( ar.isLoading() )
-         *      {
-         *              ar >> sName >> nAge >> sJob;
-         *      } else
-         *      {
-         *              ar << sName << nAge << sJob;
-         *      }
-         * }
-         @endcode
-         * Archive currently does not provide facility to make fully portable
-         * archives.  For example, it will not convert between endianness for you,
-         * nor will it take into account differences between primitive sizes on
-         * different platforms.  This, at the moment, is up to the user to ensure.
-         * One way of dealing with the latter problem is to make sure and use
-         * explicit primitive types from the stdint.h header, i.e. int32_t.
-         */
-        class Archive : public ArchiveBase
-        {
-        private:
-                bool bLoading;
-        public:
-                bool isLoading();
+     * Archive ar( sOut, Archive::save );
+     * ar << myClass;
+     @endcode
+     * In this example myClass is any class that inherits from Archival.  When
+     * the storage operator is called, the Archival::archive() function in the
+     * myClass object is called with a reference to the Archive.  This can be
+     * handled in one of two ways:
+     *@code
+     * void MyClass::archive( Archive &ar )
+     * {
+     *  ar && sName && nAge && sJob;
+     * }
+     @endcode
+     * Here we don't worry about weather we're loading or saving by using the
+     * smart && operator.  This allows us to write very consistent, very simple
+     * archive functions that really do a lot of work.  If we wanted to do
+     * something different in the case of loading or saving we would do:
+     *@code
+     * void MyClass::archive( Archive &ar )
+     * {
+     *  if( ar.isLoading() )
+     *  {
+     *      ar >> sName >> nAge >> sJob;
+     *  } else
+     *  {
+     *      ar << sName << nAge << sJob;
+     *  }
+     * }
+     @endcode
+     * Archive currently does not provide facility to make fully portable
+     * archives.  For example, it will not convert between endianness for you,
+     * nor will it take into account differences between primitive sizes on
+     * different platforms.  This, at the moment, is up to the user to ensure.
+     * One way of dealing with the latter problem is to make sure and use
+     * explicit primitive types from the stdint.h header, i.e. int32_t.
+     */
+    class Archive : public ArchiveBase
+    {
+    private:
+        bool bLoading;
+    public:
+        bool isLoading();
 
-                enum
-                {
-                        load    =       true,
-                        save    =       false
-                };
-                
-                Archive( Stream &rStream, bool bLoading );
-                virtual ~Archive();
-                virtual void close();
+        enum
+        {
+            load    =   true,
+            save    =   false
+        };
+        
+        Archive( Stream &rStream, bool bLoading );
+        virtual ~Archive();
+        virtual void close();
 
-                virtual void write( const void *pData, size_t iSize );
-                virtual void read( void *pData, size_t iSize );
-                
-                /**
-                 * For storage, get an ID for the pointer to the object you're going to
-                 * write.
-                 */
-                uint32_t getID( const void *ptr );
+        virtual void write( const void *pData, size_t iSize );
+        virtual void read( void *pData, size_t iSize );
+        
+        /**
+         * For storage, get an ID for the pointer to the object you're going to
+         * write.
+         */
+        uint32_t getID( const void *ptr );
 
-                /**
-                 * For loading.  Assosiates an empty pointer with an id.  When you wind
-                 * up loading an id reference to a pointer for an object that may or
-                 * may not have loaded yet, call this with the id, if it has been loaded
-                 * already, you'll immediately get a pointer, if not, it will write one
-                 * for you when the time comes.
-                 */
-                void assocPtrID( void **ptr, uint32_t id );
+        /**
+         * For loading.  Assosiates an empty pointer with an id.  When you wind
+         * up loading an id reference to a pointer for an object that may or
+         * may not have loaded yet, call this with the id, if it has been loaded
+         * already, you'll immediately get a pointer, if not, it will write one
+         * for you when the time comes.
+         */
+        void assocPtrID( void **ptr, uint32_t id );
 
-                /**
-                 * For loading.  Call this when you load an object that other things may
-                 * have pointers to.  It will assosiate every pointer that's been
-                 * registered with assocPtrID to the pointer passed in, and id passed
-                 * in.  It will also set things up so future calls to assocPtrID will
-                 * automatically succeed immediately.
-                 */
-                void readID( const void *ptr, uint32_t id );
+        /**
+         * For loading.  Call this when you load an object that other things may
+         * have pointers to.  It will assosiate every pointer that's been
+         * registered with assocPtrID to the pointer passed in, and id passed
+         * in.  It will also set things up so future calls to assocPtrID will
+         * automatically succeed immediately.
+         */
+        void readID( const void *ptr, uint32_t id );
 
-                template<typename t>
-                void setProp( const Bu::String &sId, const t &val )
-                {
-                        if( !hProps.has( sId ) )
-                        {
-                                hProps.insert( sId, Variant() );
-                        }
-                        hProps.get( sId ) = val;
-                }
+        template<typename t>
+        void setProp( const Bu::String &sId, const t &val )
+        {
+            if( !hProps.has( sId ) )
+            {
+                hProps.insert( sId, Variant() );
+            }
+            hProps.get( sId ) = val;
+        }
 
-                template<typename t>
-                t getProp( const Bu::String &sId )
-                {
-                        return hProps.get( sId );
-                }
+        template<typename t>
+        t getProp( const Bu::String &sId )
+        {
+            return hProps.get( sId );
+        }
 
-        private:
-                Stream &rStream;
-                uint32_t nNextID;
-                Hash<uint32_t,uint32_t> hPtrID;
-                Hash<uint32_t,List<void **> > hPtrDest;
-                Hash<Bu::String, Variant> hProps;
-        };
+    private:
+        Stream &rStream;
+        uint32_t nNextID;
+        Hash<uint32_t,uint32_t> hPtrID;
+        Hash<uint32_t,List<void **> > hPtrDest;
+        Hash<Bu::String, Variant> hProps;
+    };
 }
 
 #endif
diff --git a/src/stable/archivebase.cpp b/src/stable/archivebase.cpp
index dcf08f4..d0d22ce 100644
--- a/src/stable/archivebase.cpp
+++ b/src/stable/archivebase.cpp
@@ -17,181 +17,181 @@ Bu::ArchiveBase::~ArchiveBase()
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, bool p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, char p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed char p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned char p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed short p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned short p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed int p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned int p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed long p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned long p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, signed long long p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, unsigned long long p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, float p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, double p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, long double p)
 {
-        ar.write( &p, sizeof(p) );
-        return ar;
+    ar.write( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, bool &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, char &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed char &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned char &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed short &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned short &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed int &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned int &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed long &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned long &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, signed long long &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, unsigned long long &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, float &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, double &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, long double &p)
 {
-        ar.read( &p, sizeof(p) );
-        return ar;
+    ar.read( &p, sizeof(p) );
+    return ar;
 }
 
diff --git a/src/stable/archivebase.h b/src/stable/archivebase.h
index 34ec1af..3f9e30f 100644
--- a/src/stable/archivebase.h
+++ b/src/stable/archivebase.h
@@ -13,63 +13,63 @@
 
 namespace Bu
 {
-        class ArchiveBase
-        {
-        public:
-                ArchiveBase();
-                virtual ~ArchiveBase();
+    class ArchiveBase
+    {
+    public:
+        ArchiveBase();
+        virtual ~ArchiveBase();
 
-                virtual void close()=0;
-                virtual void write( const void *pData, size_t iLength )=0;
-                virtual void read( void *pData, size_t iLength )=0;
-                virtual bool isLoading()=0;
-        };
+        virtual void close()=0;
+        virtual void write( const void *pData, size_t iLength )=0;
+        virtual void read( void *pData, size_t iLength )=0;
+        virtual bool isLoading()=0;
+    };
 
-        template<typename T> ArchiveBase &operator&&( ArchiveBase &ar, T &dat )
-        {
-                if( ar.isLoading() )
-                {
-                        return ar >> dat;
-                }
-                else
-                {
-                        return ar << dat;
-                }
-        }
+    template<typename T> ArchiveBase &operator&&( ArchiveBase &ar, T &dat )
+    {
+        if( ar.isLoading() )
+        {
+            return ar >> dat;
+        }
+        else
+        {
+            return ar << dat;
+        }
+    }
 
-        ArchiveBase &operator<<( ArchiveBase &ar, bool p );
-        ArchiveBase &operator<<( ArchiveBase &ar, char p );
-        ArchiveBase &operator<<( ArchiveBase &ar, signed char p );
-        ArchiveBase &operator<<( ArchiveBase &ar, unsigned char p );
-        ArchiveBase &operator<<( ArchiveBase &ar, signed short p );
-        ArchiveBase &operator<<( ArchiveBase &ar, unsigned short p );
-        ArchiveBase &operator<<( ArchiveBase &ar, signed int p );
-        ArchiveBase &operator<<( ArchiveBase &ar, unsigned int p );
-        ArchiveBase &operator<<( ArchiveBase &ar, signed long p );
-        ArchiveBase &operator<<( ArchiveBase &ar, unsigned long p );
-        ArchiveBase &operator<<( ArchiveBase &ar, signed long long p );
-        ArchiveBase &operator<<( ArchiveBase &ar, unsigned long long p );
-        ArchiveBase &operator<<( ArchiveBase &ar, float p );
-        ArchiveBase &operator<<( ArchiveBase &ar, double p );
-        ArchiveBase &operator<<( ArchiveBase &ar, long double p );
-        
-        ArchiveBase &operator>>( ArchiveBase &ar, bool &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, char &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, signed char &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, unsigned char &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, signed short &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, unsigned short &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, signed int &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, unsigned int &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, signed long &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, unsigned long &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, signed long long &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, unsigned long long &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, float &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, double &p );
-        ArchiveBase &operator>>( ArchiveBase &ar, long double &p );
+    ArchiveBase &operator<<( ArchiveBase &ar, bool p );
+    ArchiveBase &operator<<( ArchiveBase &ar, char p );
+    ArchiveBase &operator<<( ArchiveBase &ar, signed char p );
+    ArchiveBase &operator<<( ArchiveBase &ar, unsigned char p );
+    ArchiveBase &operator<<( ArchiveBase &ar, signed short p );
+    ArchiveBase &operator<<( ArchiveBase &ar, unsigned short p );
+    ArchiveBase &operator<<( ArchiveBase &ar, signed int p );
+    ArchiveBase &operator<<( ArchiveBase &ar, unsigned int p );
+    ArchiveBase &operator<<( ArchiveBase &ar, signed long p );
+    ArchiveBase &operator<<( ArchiveBase &ar, unsigned long p );
+    ArchiveBase &operator<<( ArchiveBase &ar, signed long long p );
+    ArchiveBase &operator<<( ArchiveBase &ar, unsigned long long p );
+    ArchiveBase &operator<<( ArchiveBase &ar, float p );
+    ArchiveBase &operator<<( ArchiveBase &ar, double p );
+    ArchiveBase &operator<<( ArchiveBase &ar, long double p );
+    
+    ArchiveBase &operator>>( ArchiveBase &ar, bool &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, char &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, signed char &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, unsigned char &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, signed short &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, unsigned short &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, signed int &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, unsigned int &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, signed long &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, unsigned long &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, signed long long &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, unsigned long long &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, float &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, double &p );
+    ArchiveBase &operator>>( ArchiveBase &ar, long double &p );
 
-        
+    
 };
 
 #endif
diff --git a/src/stable/array.h b/src/stable/array.h
index f765e75..324c9ac 100644
--- a/src/stable/array.h
+++ b/src/stable/array.h
@@ -15,697 +15,697 @@
 
 namespace Bu
 {
-        subExceptionDecl( ArrayException )
-
-        template<typename value, int inc, typename valuealloc>
-        class Array;
-
-        /** @cond DEVEL */
-        template<typename value, int inc, typename valuealloc>
-        class ArrayCore
-        {
-        friend class Array<value, inc, valuealloc>;
-        friend class SharedCore<
-                Array<value, inc, valuealloc>,
-                ArrayCore<value, inc, valuealloc>
-                >;
-        private:                
-                ArrayCore() :
-                        pData( NULL ),
-                        iSize( 0 ),
-                        iCapacity( 0 )
-                { }
-
-                void setCapacity( int iNewLen )
-                {
-                        //clear();
-                        //iCapacity = iCapacity;
-                        //pData = va.allocate( iCapacity );
-                        if( iNewLen <= iCapacity ) return;
-                        value *pNewData = va.allocate( iNewLen );
-                        if( pData )
-                        {
-                                for( int j = 0; j < iSize; j++ )
-                                {
-                                        va.construct( &pNewData[j], pData[j] );
-                                        va.destroy( &pData[j] );
-                                }
-                                va.deallocate( pData, iCapacity );
-                        }
-                        pData = pNewData;
-                        iCapacity = iNewLen;
-                }
-
-                virtual ~ArrayCore()
-                {
-                        clear();
-                }
-
-                void clear()
-                {
-                        if( pData )
-                        {
-                                for( int j = 0; j < iSize; j++ )
-                                {
-                                        va.destroy( &pData[j] );
-                                }
-                                va.deallocate( pData, iCapacity );
-                                pData = NULL;
-                        }
-                        iSize = 0;
-                        iCapacity = 0;
-                }
-
-                void erase( int iPos )
-                {
-                        for( int j = iPos; j < iSize; j++ )
-                        {
-                                va.destroy( &pData[j] );
-                                if( j == iSize-1 )
-                                {
-                                        iSize--;
-                                        return;
-                                }
-                                va.construct( &pData[j], pData[j+1] );
-                        }
-                }
-
-                void swapErase( int iPos )
-                {
-                        if( iPos == iSize-1 )
-                        {
-                                erase( iPos );
-                                return;
-                        }
-                        va.destroy( &pData[iPos] );
-                        va.construct( &pData[iPos], pData[iSize-1] );
-                        va.destroy( &pData[iSize-1] );
-                        iSize--;
-                }
-
-                valuealloc va;
-                value *pData;
-                long iSize;
-                long iCapacity;
-        };
-        /** @endcond */
-
-        /**
-         * Array type container, just like a normal array only flexible and keeps
-         * track of your memory for you.
-         *
-         *@param value (typename) The type of data to store in your list
-         *@param valuealloc (typename) Memory Allocator for your value type
-         *@param linkalloc (typename) Memory Allocator for the list links.
-         *@ingroup Containers
-         */
-        template<typename value, int inc=10, typename valuealloc=std::allocator<value> >
-        class Array : public SharedCore<
-                                  Array<value, inc, valuealloc>,
-                                  ArrayCore<value, inc, valuealloc>
-                                  >
-        {
-        private:
-                typedef class Array<value, inc, valuealloc> MyType;
-                typedef class ArrayCore<value, inc, valuealloc> Core;
-
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_resetCore;
-                using SharedCore<MyType, Core>::_allocateCore;
-
-        public:
-                struct const_iterator;
-                struct iterator;
-
-                Array()
-                {
-                }
-
-                Array( const MyType &src ) :
-                        SharedCore<MyType, Core >( src )
-                {
-                }
-                
-                Array( long iSetCap )
-                {
-                        setCapacity( iSetCap );
-                }
-
-                ~Array()
-                {
-                }
-
-                bool operator==( const MyType &src ) const
-                {
-                        if( core == src.core )
-                                return true;
-                        if( core->iSize != src.core->iSize )
-                                return false;
-
-                        for( int j = 0; j < core->iSize; j++ )
-                        {
-                                if( core->pData[j] != src.core->pData[j] )
-                                        return false;
-                        }
-                        return true;
-                }
-
-                bool operator!=( const MyType &src ) const
-                {
-                        return !(*this == src);
-                }
-
-                /**
-                 * Clear the array.
-                 */
-                void clear()
-                {
-                        _resetCore();
-                }
-
-                MyType &append( const value &rVal )
-                {
-                        _hardCopy();
-                        if( core->iSize == core->iCapacity )
-                        {
-                                core->setCapacity( core->iCapacity + inc );
-                        }
-
-                        core->va.construct( &core->pData[core->iSize++], rVal );
-
-                        return *this;
-                }
-                
-                MyType &append( const MyType &rVal )
-                {
-                        _hardCopy();
-
-                        if( core->iSize + rVal.core->iSize > core->iCapacity )
-                        {
-                                core->setCapacity( core->iSize + rVal.core->iSize + inc );
-                        }
-                        
-                        for( int j = 0; j < rVal.core->iSize; j++ )
-                        {
-                                core->va.construct(
-                                        &core->pData[core->iSize++],
-                                        rVal.core->pData[j]
-                                        );
-                        }
-
-                        return *this;
-                }
-
-                //operator
-                value &operator[]( long iIndex )
-                {
-                        _hardCopy();
-                        if( iIndex < 0 || iIndex >= core->iSize )
-                                throw ArrayException(
-                                        "Index %d out of range 0:%d", iIndex, core->iSize );
-
-                        return core->pData[iIndex];
-                }
-                
-                const value &operator[]( long iIndex ) const
-                {
-                        if( iIndex < 0 || iIndex >= core->iSize )
-                                throw ArrayException(
-                                        "Index %d out of range 0:%d", iIndex, core->iSize );
-
-                        return core->pData[iIndex];
-                }
-
-                value &get( long iIndex )
-                {
-                        _hardCopy();
-                        if( iIndex < 0 || iIndex >= core->iSize )
-                                throw ArrayException(
-                                        "Index %d out of range 0:%d", iIndex, core->iSize );
-
-                        return core->pData[iIndex];
-                }
-
-                const value &get( long iIndex ) const
-                {
-                        if( iIndex < 0 || iIndex >= core->iSize )
-                                throw ArrayException(
-                                        "Index %d out of range 0:%d", iIndex, core->iSize );
-
-                        return core->pData[iIndex];
-                }
-
-                value &first()
-                {
-                        _hardCopy();
-                        return core->pData[0];
-                }
-
-                const value &first() const
-                {
-                        return core->pData[0];
-                }
-
-                value &last()
-                {
-                        _hardCopy();
-                        return core->pData[core->iSize-1];
-                }
-
-                const value &last() const
-                {
-                        return core->pData[core->iSize-1];
-                }
-
-                /**
-                 * Returns true if the array is empty.  The capacity has no bearing on
-                 * this, only the size.
-                 */
-                bool isEmpty() const
-                {
-                        return core->iSize==0;
-                }
-
-                /**
-                 * Get the current size of the array.
-                 *@returns The current size of the array.
-                 */
-                long getSize() const
-                {
-                        return core->iSize;
-                }
-
-                /**
-                 * Get the capacity of the array.  This number will grow as data is
-                 * added, and is mainly for the curious, it doesn't really determine
-                 * much for the end user.
-                 *@returns The current capacity of the array.
-                 */
-                long getCapacity() const
-                {
-                        return core->iCapacity;
-                }
-
-                /**
-                 * Change the capacity of the array, very useful if you know you'll be
-                 * adding a large amount of already counted items to the array, makes
-                 * the appending much faster afterwords.
-                 *@param iNewLen The new capacity of the array.
-                 *@todo Set this up so it can reduce the size of the array as well as
-                 * make it bigger.
-                 */
-                void setCapacity( long iNewLen )
-                {
-                        _hardCopy();
-                        core->setCapacity( iNewLen );
-                }
-
-                typedef struct iterator
-                {
-                        friend class Array<value, inc, valuealloc>;
-                private:
-                        iterator( MyType &src, long iPos=0 ) :
-                                src( src ),
-                                iPos( iPos )
-                        {
-                                if( this->iPos >= src.getSize() )
-                                        this->iPos = -1;
-                        }
-
-                        MyType &src;
-                        long iPos;
-
-                public:
-                        iterator operator++( int )
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot increment iterator past end of array.");
-                                        iPos++;
-                                if( iPos >= src.getSize() )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        iterator operator++()
-                        {
-                                if( iPos >= 0 )
-                                        iPos++;
-                                if( iPos >= src.getSize() )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        iterator operator+( int iAmnt )
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot increment iterator past end of array.");
-                                        iPos += iAmnt;
-                                if( iPos >= src.getSize() )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        iterator operator--( int )
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot increment iterator past end of array.");
-                                        iPos--;
-                                if( iPos < 0 )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        iterator operator--()
-                        {
-                                if( iPos < src.getSize() )
-                                        iPos--;
-                                if( iPos <= 0 )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        iterator operator-( int iAmnt )
-                        {
-                                if( iPos < src.getSize() )
-                                        iPos -= iAmnt;
-                                if( iPos <= 0 )
-                                        iPos = -1;
-                                return *this;
-                        }
-
-                        bool operator==( const iterator &oth ) const
-                        {
-                                return iPos == oth.iPos;
-                        }
-
-                        bool operator!=( const iterator &oth ) const
-                        {
-                                return iPos != oth.iPos;
-                        }
-
-                        iterator operator=( const iterator &oth )
-                        {
-                                if( &src != &oth.src )
-                                        throw ArrayException(
-                                                "Cannot mix iterators from different array objects.");
-                                iPos = oth.iPos;
-                        }
-
-                        value &operator*()
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot dereference finished iterator.");
-                                return src[iPos];
-                        }
-
-                        long getIndex() const
-                        {
-                                return iPos;
-                        }
-
-                        operator bool() const
-                        {
-                                return iPos >= 0;
-                        }
-
-                        bool isValid() const
-                        {
-                                return iPos >= 0;
-                        }
-                } iterator;
-                
-                typedef struct const_iterator
-                {
-                        friend class Array<value, inc, valuealloc>;
-                private:
-                        const_iterator( const MyType &src, long iPos=0 ) :
-                                src( src ),
-                                iPos( iPos )
-                        {
-                                if( this->iPos >= src.getSize() )
-                                        this->iPos = -1;
-                        }
-
-                        const MyType &src;
-                        long iPos;
-
-                public:
-                        const_iterator( iterator &rSrc ) :
-                                src( rSrc.src ),
-                                iPos( rSrc.iPos )
-                        {
-                        }
-                        const_iterator operator++( int )
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot increment iterator past end of array.");
-                                        iPos++;
-                                if( iPos >= src.getSize() )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        const_iterator operator++()
-                        {
-                                if( iPos >= 0 )
-                                        iPos++;
-                                if( iPos >= src.getSize() )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        const_iterator operator--( int )
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot increment iterator past end of array.");
-                                        iPos--;
-                                if( iPos < 0 )
-                                        iPos = -1;
-                                return *this;
-                        }
-                        
-                        const_iterator operator--()
-                        {
-                                if( iPos < src.getSize() )
-                                        iPos--;
-                                if( iPos <= 0 )
-                                        iPos = -1;
-                                return *this;
-                        }
-
-                        bool operator==( const const_iterator &oth ) const
-                        {
-                                return iPos == oth.iPos;
-                        }
-
-                        bool operator!=( const const_iterator &oth ) const
-                        {
-                                return iPos != oth.iPos;
-                        }
-
-                        const_iterator operator=( const const_iterator &oth )
-                        {
-                                if( &src != &oth.src )
-                                        throw ArrayException(
-                                                "Cannot mix iterators from different array objects.");
-                                iPos = oth.iPos;
-                        }
-
-                        const value &operator*() const
-                        {
-                                if( iPos < 0 )
-                                        throw ArrayException(
-                                                "Cannot dereference finished iterator.");
-                                return src[iPos];
-                        }
-
-                        long getIndex() const
-                        {
-                                return iPos;
-                        }
-                        
-                        operator bool() const
-                        {
-                                return iPos >= 0;
-                        }
-
-                        bool isValid() const
-                        {
-                                return iPos >= 0;
-                        }
-                } const_iterator;
-
-                iterator begin()
-                {
-                        return iterator( *this );
-                }
-
-                const_iterator begin() const
-                {
-                        return const_iterator( *this );
-                }
-
-                iterator end()
-                {
-                        return iterator( *this, -1 );
-                }
-
-                const_iterator end() const
-                {
-                        return const_iterator( *this, -1 );
-                }
-
-                MyType &insert( iterator i, const value &rVal )
-                {
-                        if( i.iPos == -1 )
-                        {
-                                append( rVal );
-                                return *this;
-                        }
-
-                        _hardCopy();
-                        if( core->iSize == core->iCapacity )
-                        {
-                                core->setCapacity( core->iCapacity + inc );
-                        }
-                        core->iSize++;
-
-                        core->va.construct(
-                                &core->pData[core->iSize-1],
-                                core->pData[core->iSize-2]
-                                );
-                        for( int iPos = core->iSize-2; iPos > i.iPos; iPos-- )
-                        {
-                                core->va.destroy( &core->pData[iPos] );
-                                core->va.construct( &core->pData[iPos], core->pData[iPos-1] );
-                        }
-                        core->va.destroy( &core->pData[i.iPos] );
-                        core->va.construct( &core->pData[i.iPos], rVal );
-
-                        return *this;
-                }
-
-                /**
-                 * If order is important, use this.  It will delete the suggested item
-                 * and move the rest of the data up a spot.  This is a time O(n)
-                 * operation.  If the order isn't important, check swapErase
-                 */
-                void erase( iterator i )
-                {
-                        _hardCopy();
-                        core->erase( i.iPos );
-                }
-
-                void erase( const value &v )
-                {
-                        _hardCopy();
-                        for( int j = 0; j < core->iSize; j++ )
-                        {
-                                if( core->pData[j] == v )
-                                {
-                                        core->erase( j );
-                                        return;
-                                }
-                        }
-                }
-
-                void eraseLast()
-                {
-                        _hardCopy();
-                        core->erase( core->iSize-1 );
-                }
-
-                void eraseFirst()
-                {
-                        _hardCopy();
-                        core->erase( 0 );
-                }
-
-                /**
-                 * In order to make swapErase faster, what it does is swap the given
-                 * item in the array with the last item, then make the array shorter
-                 * by one.  It changes the order of the elements in the array, so it
-                 * should be used carefully, but it is time O(1) instead of O(n) like
-                 * erase.
-                 */
-                void swapErase( iterator i )
-                {
-                        _hardCopy();
-                        core->swapErase( i.iPos );
-                }
-
-        protected:
-                virtual Core *_copyCore( Core *src )
-                {
-                        Core *pRet = _allocateCore();
-                        pRet->setCapacity( src->iCapacity );
-                        pRet->iSize = src->iSize;
-                        for( int j = 0; j < src->iSize; j++ )
-                        {       
-                                pRet->va.construct( &pRet->pData[j], src->pData[j] );
-                        }
-                        return pRet;
-                }
-
-        private:
-        };
-
-        class Formatter;
-        Formatter &operator<<( Formatter &rOut, char *sStr );
-        Formatter &operator<<( Formatter &rOut, signed char c );
-        template<typename value>
-        Formatter &operator<<( Formatter &f, const Bu::Array<value> &a )
-        {
-                f << '[';
-                for( typename Bu::Array<value>::const_iterator i = a.begin(); i; i++ )
-                {
-                        if( i != a.begin() )
-                                f << ", ";
-                        f << *i;
-                }
-                f << ']';
-
-                return f;
-        }
-
-        template<typename value, int inc, typename valuealloc>
-        ArchiveBase &operator<<( ArchiveBase &ar,
-                        const Array<value, inc, valuealloc> &h )
-        {
-                ar << h.getSize();
-                for( typename Array<value, inc, valuealloc>::const_iterator i =
-                         h.begin(); i != h.end(); i++ )
-                {
-                        ar << (*i);
-                }
-
-                return ar;
-        }
-
-        template<typename value, int inc, typename valuealloc>
-        ArchiveBase &operator>>(ArchiveBase &ar, Array<value, inc, valuealloc> &h )
-        {
-                h.clear();
-                long nSize;
-                ar >> nSize;
-
-                h.setCapacity( nSize );
-                for( long j = 0; j < nSize; j++ )
-                {
-                        value v;
-                        ar >> v;
-                        h.append( v );
-                }
-                return ar;
-        }
+    subExceptionDecl( ArrayException )
+
+    template<typename value, int inc, typename valuealloc>
+    class Array;
+
+    /** @cond DEVEL */
+    template<typename value, int inc, typename valuealloc>
+    class ArrayCore
+    {
+    friend class Array<value, inc, valuealloc>;
+    friend class SharedCore<
+        Array<value, inc, valuealloc>,
+        ArrayCore<value, inc, valuealloc>
+        >;
+    private:        
+        ArrayCore() :
+            pData( NULL ),
+            iSize( 0 ),
+            iCapacity( 0 )
+        { }
+
+        void setCapacity( int iNewLen )
+        {
+            //clear();
+            //iCapacity = iCapacity;
+            //pData = va.allocate( iCapacity );
+            if( iNewLen <= iCapacity ) return;
+            value *pNewData = va.allocate( iNewLen );
+            if( pData )
+            {
+                for( int j = 0; j < iSize; j++ )
+                {
+                    va.construct( &pNewData[j], pData[j] );
+                    va.destroy( &pData[j] );
+                }
+                va.deallocate( pData, iCapacity );
+            }
+            pData = pNewData;
+            iCapacity = iNewLen;
+        }
+
+        virtual ~ArrayCore()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            if( pData )
+            {
+                for( int j = 0; j < iSize; j++ )
+                {
+                    va.destroy( &pData[j] );
+                }
+                va.deallocate( pData, iCapacity );
+                pData = NULL;
+            }
+            iSize = 0;
+            iCapacity = 0;
+        }
+
+        void erase( int iPos )
+        {
+            for( int j = iPos; j < iSize; j++ )
+            {
+                va.destroy( &pData[j] );
+                if( j == iSize-1 )
+                {
+                    iSize--;
+                    return;
+                }
+                va.construct( &pData[j], pData[j+1] );
+            }
+        }
+
+        void swapErase( int iPos )
+        {
+            if( iPos == iSize-1 )
+            {
+                erase( iPos );
+                return;
+            }
+            va.destroy( &pData[iPos] );
+            va.construct( &pData[iPos], pData[iSize-1] );
+            va.destroy( &pData[iSize-1] );
+            iSize--;
+        }
+
+        valuealloc va;
+        value *pData;
+        long iSize;
+        long iCapacity;
+    };
+    /** @endcond */
+
+    /**
+     * Array type container, just like a normal array only flexible and keeps
+     * track of your memory for you.
+     *
+     *@param value (typename) The type of data to store in your list
+     *@param valuealloc (typename) Memory Allocator for your value type
+     *@param linkalloc (typename) Memory Allocator for the list links.
+     *@ingroup Containers
+     */
+    template<typename value, int inc=10, typename valuealloc=std::allocator<value> >
+    class Array : public SharedCore<
+                  Array<value, inc, valuealloc>,
+                  ArrayCore<value, inc, valuealloc>
+                  >
+    {
+    private:
+        typedef class Array<value, inc, valuealloc> MyType;
+        typedef class ArrayCore<value, inc, valuealloc> Core;
+
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_resetCore;
+        using SharedCore<MyType, Core>::_allocateCore;
+
+    public:
+        struct const_iterator;
+        struct iterator;
+
+        Array()
+        {
+        }
+
+        Array( const MyType &src ) :
+            SharedCore<MyType, Core >( src )
+        {
+        }
+        
+        Array( long iSetCap )
+        {
+            setCapacity( iSetCap );
+        }
+
+        ~Array()
+        {
+        }
+
+        bool operator==( const MyType &src ) const
+        {
+            if( core == src.core )
+                return true;
+            if( core->iSize != src.core->iSize )
+                return false;
+
+            for( int j = 0; j < core->iSize; j++ )
+            {
+                if( core->pData[j] != src.core->pData[j] )
+                    return false;
+            }
+            return true;
+        }
+
+        bool operator!=( const MyType &src ) const
+        {
+            return !(*this == src);
+        }
+
+        /**
+         * Clear the array.
+         */
+        void clear()
+        {
+            _resetCore();
+        }
+
+        MyType &append( const value &rVal )
+        {
+            _hardCopy();
+            if( core->iSize == core->iCapacity )
+            {
+                core->setCapacity( core->iCapacity + inc );
+            }
+
+            core->va.construct( &core->pData[core->iSize++], rVal );
+
+            return *this;
+        }
+        
+        MyType &append( const MyType &rVal )
+        {
+            _hardCopy();
+
+            if( core->iSize + rVal.core->iSize > core->iCapacity )
+            {
+                core->setCapacity( core->iSize + rVal.core->iSize + inc );
+            }
+            
+            for( int j = 0; j < rVal.core->iSize; j++ )
+            {
+                core->va.construct(
+                    &core->pData[core->iSize++],
+                    rVal.core->pData[j]
+                    );
+            }
+
+            return *this;
+        }
+
+        //operator
+        value &operator[]( long iIndex )
+        {
+            _hardCopy();
+            if( iIndex < 0 || iIndex >= core->iSize )
+                throw ArrayException(
+                    "Index %d out of range 0:%d", iIndex, core->iSize );
+
+            return core->pData[iIndex];
+        }
+        
+        const value &operator[]( long iIndex ) const
+        {
+            if( iIndex < 0 || iIndex >= core->iSize )
+                throw ArrayException(
+                    "Index %d out of range 0:%d", iIndex, core->iSize );
+
+            return core->pData[iIndex];
+        }
+
+        value &get( long iIndex )
+        {
+            _hardCopy();
+            if( iIndex < 0 || iIndex >= core->iSize )
+                throw ArrayException(
+                    "Index %d out of range 0:%d", iIndex, core->iSize );
+
+            return core->pData[iIndex];
+        }
+
+        const value &get( long iIndex ) const
+        {
+            if( iIndex < 0 || iIndex >= core->iSize )
+                throw ArrayException(
+                    "Index %d out of range 0:%d", iIndex, core->iSize );
+
+            return core->pData[iIndex];
+        }
+
+        value &first()
+        {
+            _hardCopy();
+            return core->pData[0];
+        }
+
+        const value &first() const
+        {
+            return core->pData[0];
+        }
+
+        value &last()
+        {
+            _hardCopy();
+            return core->pData[core->iSize-1];
+        }
+
+        const value &last() const
+        {
+            return core->pData[core->iSize-1];
+        }
+
+        /**
+         * Returns true if the array is empty.  The capacity has no bearing on
+         * this, only the size.
+         */
+        bool isEmpty() const
+        {
+            return core->iSize==0;
+        }
+
+        /**
+         * Get the current size of the array.
+         *@returns The current size of the array.
+         */
+        long getSize() const
+        {
+            return core->iSize;
+        }
+
+        /**
+         * Get the capacity of the array.  This number will grow as data is
+         * added, and is mainly for the curious, it doesn't really determine
+         * much for the end user.
+         *@returns The current capacity of the array.
+         */
+        long getCapacity() const
+        {
+            return core->iCapacity;
+        }
+
+        /**
+         * Change the capacity of the array, very useful if you know you'll be
+         * adding a large amount of already counted items to the array, makes
+         * the appending much faster afterwords.
+         *@param iNewLen The new capacity of the array.
+         *@todo Set this up so it can reduce the size of the array as well as
+         * make it bigger.
+         */
+        void setCapacity( long iNewLen )
+        {
+            _hardCopy();
+            core->setCapacity( iNewLen );
+        }
+
+        typedef struct iterator
+        {
+            friend class Array<value, inc, valuealloc>;
+        private:
+            iterator( MyType &src, long iPos=0 ) :
+                src( src ),
+                iPos( iPos )
+            {
+                if( this->iPos >= src.getSize() )
+                    this->iPos = -1;
+            }
+
+            MyType &src;
+            long iPos;
+
+        public:
+            iterator operator++( int )
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot increment iterator past end of array.");
+                    iPos++;
+                if( iPos >= src.getSize() )
+                    iPos = -1;
+                return *this;
+            }
+            
+            iterator operator++()
+            {
+                if( iPos >= 0 )
+                    iPos++;
+                if( iPos >= src.getSize() )
+                    iPos = -1;
+                return *this;
+            }
+            
+            iterator operator+( int iAmnt )
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot increment iterator past end of array.");
+                    iPos += iAmnt;
+                if( iPos >= src.getSize() )
+                    iPos = -1;
+                return *this;
+            }
+            
+            iterator operator--( int )
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot increment iterator past end of array.");
+                    iPos--;
+                if( iPos < 0 )
+                    iPos = -1;
+                return *this;
+            }
+            
+            iterator operator--()
+            {
+                if( iPos < src.getSize() )
+                    iPos--;
+                if( iPos <= 0 )
+                    iPos = -1;
+                return *this;
+            }
+            
+            iterator operator-( int iAmnt )
+            {
+                if( iPos < src.getSize() )
+                    iPos -= iAmnt;
+                if( iPos <= 0 )
+                    iPos = -1;
+                return *this;
+            }
+
+            bool operator==( const iterator &oth ) const
+            {
+                return iPos == oth.iPos;
+            }
+
+            bool operator!=( const iterator &oth ) const
+            {
+                return iPos != oth.iPos;
+            }
+
+            iterator operator=( const iterator &oth )
+            {
+                if( &src != &oth.src )
+                    throw ArrayException(
+                        "Cannot mix iterators from different array objects.");
+                iPos = oth.iPos;
+            }
+
+            value &operator*()
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot dereference finished iterator.");
+                return src[iPos];
+            }
+
+            long getIndex() const
+            {
+                return iPos;
+            }
+
+            operator bool() const
+            {
+                return iPos >= 0;
+            }
+
+            bool isValid() const
+            {
+                return iPos >= 0;
+            }
+        } iterator;
+        
+        typedef struct const_iterator
+        {
+            friend class Array<value, inc, valuealloc>;
+        private:
+            const_iterator( const MyType &src, long iPos=0 ) :
+                src( src ),
+                iPos( iPos )
+            {
+                if( this->iPos >= src.getSize() )
+                    this->iPos = -1;
+            }
+
+            const MyType &src;
+            long iPos;
+
+        public:
+            const_iterator( iterator &rSrc ) :
+                src( rSrc.src ),
+                iPos( rSrc.iPos )
+            {
+            }
+            const_iterator operator++( int )
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot increment iterator past end of array.");
+                    iPos++;
+                if( iPos >= src.getSize() )
+                    iPos = -1;
+                return *this;
+            }
+            
+            const_iterator operator++()
+            {
+                if( iPos >= 0 )
+                    iPos++;
+                if( iPos >= src.getSize() )
+                    iPos = -1;
+                return *this;
+            }
+            
+            const_iterator operator--( int )
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot increment iterator past end of array.");
+                    iPos--;
+                if( iPos < 0 )
+                    iPos = -1;
+                return *this;
+            }
+            
+            const_iterator operator--()
+            {
+                if( iPos < src.getSize() )
+                    iPos--;
+                if( iPos <= 0 )
+                    iPos = -1;
+                return *this;
+            }
+
+            bool operator==( const const_iterator &oth ) const
+            {
+                return iPos == oth.iPos;
+            }
+
+            bool operator!=( const const_iterator &oth ) const
+            {
+                return iPos != oth.iPos;
+            }
+
+            const_iterator operator=( const const_iterator &oth )
+            {
+                if( &src != &oth.src )
+                    throw ArrayException(
+                        "Cannot mix iterators from different array objects.");
+                iPos = oth.iPos;
+            }
+
+            const value &operator*() const
+            {
+                if( iPos < 0 )
+                    throw ArrayException(
+                        "Cannot dereference finished iterator.");
+                return src[iPos];
+            }
+
+            long getIndex() const
+            {
+                return iPos;
+            }
+            
+            operator bool() const
+            {
+                return iPos >= 0;
+            }
+
+            bool isValid() const
+            {
+                return iPos >= 0;
+            }
+        } const_iterator;
+
+        iterator begin()
+        {
+            return iterator( *this );
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator( *this );
+        }
+
+        iterator end()
+        {
+            return iterator( *this, -1 );
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator( *this, -1 );
+        }
+
+        MyType &insert( iterator i, const value &rVal )
+        {
+            if( i.iPos == -1 )
+            {
+                append( rVal );
+                return *this;
+            }
+
+            _hardCopy();
+            if( core->iSize == core->iCapacity )
+            {
+                core->setCapacity( core->iCapacity + inc );
+            }
+            core->iSize++;
+
+            core->va.construct(
+                &core->pData[core->iSize-1],
+                core->pData[core->iSize-2]
+                );
+            for( int iPos = core->iSize-2; iPos > i.iPos; iPos-- )
+            {
+                core->va.destroy( &core->pData[iPos] );
+                core->va.construct( &core->pData[iPos], core->pData[iPos-1] );
+            }
+            core->va.destroy( &core->pData[i.iPos] );
+            core->va.construct( &core->pData[i.iPos], rVal );
+
+            return *this;
+        }
+
+        /**
+         * If order is important, use this.  It will delete the suggested item
+         * and move the rest of the data up a spot.  This is a time O(n)
+         * operation.  If the order isn't important, check swapErase
+         */
+        void erase( iterator i )
+        {
+            _hardCopy();
+            core->erase( i.iPos );
+        }
+
+        void erase( const value &v )
+        {
+            _hardCopy();
+            for( int j = 0; j < core->iSize; j++ )
+            {
+                if( core->pData[j] == v )
+                {
+                    core->erase( j );
+                    return;
+                }
+            }
+        }
+
+        void eraseLast()
+        {
+            _hardCopy();
+            core->erase( core->iSize-1 );
+        }
+
+        void eraseFirst()
+        {
+            _hardCopy();
+            core->erase( 0 );
+        }
+
+        /**
+         * In order to make swapErase faster, what it does is swap the given
+         * item in the array with the last item, then make the array shorter
+         * by one.  It changes the order of the elements in the array, so it
+         * should be used carefully, but it is time O(1) instead of O(n) like
+         * erase.
+         */
+        void swapErase( iterator i )
+        {
+            _hardCopy();
+            core->swapErase( i.iPos );
+        }
+
+    protected:
+        virtual Core *_copyCore( Core *src )
+        {
+            Core *pRet = _allocateCore();
+            pRet->setCapacity( src->iCapacity );
+            pRet->iSize = src->iSize;
+            for( int j = 0; j < src->iSize; j++ )
+            {   
+                pRet->va.construct( &pRet->pData[j], src->pData[j] );
+            }
+            return pRet;
+        }
+
+    private:
+    };
+
+    class Formatter;
+    Formatter &operator<<( Formatter &rOut, char *sStr );
+    Formatter &operator<<( Formatter &rOut, signed char c );
+    template<typename value>
+    Formatter &operator<<( Formatter &f, const Bu::Array<value> &a )
+    {
+        f << '[';
+        for( typename Bu::Array<value>::const_iterator i = a.begin(); i; i++ )
+        {
+            if( i != a.begin() )
+                f << ", ";
+            f << *i;
+        }
+        f << ']';
+
+        return f;
+    }
+
+    template<typename value, int inc, typename valuealloc>
+    ArchiveBase &operator<<( ArchiveBase &ar,
+            const Array<value, inc, valuealloc> &h )
+    {
+        ar << h.getSize();
+        for( typename Array<value, inc, valuealloc>::const_iterator i =
+             h.begin(); i != h.end(); i++ )
+        {
+            ar << (*i);
+        }
+
+        return ar;
+    }
+
+    template<typename value, int inc, typename valuealloc>
+    ArchiveBase &operator>>(ArchiveBase &ar, Array<value, inc, valuealloc> &h )
+    {
+        h.clear();
+        long nSize;
+        ar >> nSize;
+
+        h.setCapacity( nSize );
+        for( long j = 0; j < nSize; j++ )
+        {
+            value v;
+            ar >> v;
+            h.append( v );
+        }
+        return ar;
+    }
 
 }
 
diff --git a/src/stable/atom.h b/src/stable/atom.h
index 105c29a..9679ab6 100644
--- a/src/stable/atom.h
+++ b/src/stable/atom.h
@@ -15,133 +15,133 @@
 
 namespace Bu
 {
-        /**
-         *
-         *@ingroup Containers
-         */
-        template <typename t, typename talloc=std::allocator<t> >
-        class Atom
-        {
-        private:
-                typedef struct Atom<t, talloc> MyType;
-
-        public:
-                Atom() :
-                        pData( NULL )
-                {
-                }
-
-                Atom( const MyType &oth ) :
-                        pData( NULL )
-                {
-                        if( oth.pData )
-                                set( *oth.pData );
-                }
-
-                Atom( const t &oth ) :
-                        pData( NULL )
-                {
-                        set( oth );
-                }
-
-                virtual ~Atom()
-                {
-                        clear();
-                }
-
-                bool has() const
-                {
-                        return (pData != NULL);
-                }
-
-                void set( const t &val )
-                {
-                        clear();
-                        pData = ta.allocate( 1 );
-                        ta.construct( pData, val );
-                }
-
-                t &get()
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return *pData;
-                }
-
-                const t &get() const
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return *pData;
-                }
-
-                void clear()
-                {
-                        if( pData )
-                        {
-                                ta.destroy( pData );
-                                ta.deallocate( pData, 1 );
-                                pData = NULL;
-                        }
-                }
-
-                operator const t &() const
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return *pData;
-                }
-                
-                operator t &()
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return *pData;
-                }
-
-                MyType &operator =( const t &oth )
-                {
-                        set( oth );
-
-                        return *this;
-                }
-                
-                MyType &operator =( const MyType &oth )
-                {
-                        if( oth.pData )
-                                set( *oth.pData );
-
-                        return *this;
-                }
-                
-                bool operator ==( const MyType &oth )
-                {
-                        return (*pData) == (*oth.pData);
-                }
-
-                bool operator ==( const t &oth )
-                {
-                        return (*pData) == oth;
-                }
-
-                t *operator ->()
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return pData;
-                }
-
-                t &operator *()
-                {
-                        if( !pData )
-                                throw Bu::ExceptionBase("Not set");
-                        return *pData;
-                }
-
-        private:
-                t *pData;
-                talloc ta;
-        };
+    /**
+     *
+     *@ingroup Containers
+     */
+    template <typename t, typename talloc=std::allocator<t> >
+    class Atom
+    {
+    private:
+        typedef struct Atom<t, talloc> MyType;
+
+    public:
+        Atom() :
+            pData( NULL )
+        {
+        }
+
+        Atom( const MyType &oth ) :
+            pData( NULL )
+        {
+            if( oth.pData )
+                set( *oth.pData );
+        }
+
+        Atom( const t &oth ) :
+            pData( NULL )
+        {
+            set( oth );
+        }
+
+        virtual ~Atom()
+        {
+            clear();
+        }
+
+        bool has() const
+        {
+            return (pData != NULL);
+        }
+
+        void set( const t &val )
+        {
+            clear();
+            pData = ta.allocate( 1 );
+            ta.construct( pData, val );
+        }
+
+        t &get()
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return *pData;
+        }
+
+        const t &get() const
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return *pData;
+        }
+
+        void clear()
+        {
+            if( pData )
+            {
+                ta.destroy( pData );
+                ta.deallocate( pData, 1 );
+                pData = NULL;
+            }
+        }
+
+        operator const t &() const
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return *pData;
+        }
+        
+        operator t &()
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return *pData;
+        }
+
+        MyType &operator =( const t &oth )
+        {
+            set( oth );
+
+            return *this;
+        }
+        
+        MyType &operator =( const MyType &oth )
+        {
+            if( oth.pData )
+                set( *oth.pData );
+
+            return *this;
+        }
+        
+        bool operator ==( const MyType &oth )
+        {
+            return (*pData) == (*oth.pData);
+        }
+
+        bool operator ==( const t &oth )
+        {
+            return (*pData) == oth;
+        }
+
+        t *operator ->()
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return pData;
+        }
+
+        t &operator *()
+        {
+            if( !pData )
+                throw Bu::ExceptionBase("Not set");
+            return *pData;
+        }
+
+    private:
+        t *pData;
+        talloc ta;
+    };
 }
 
 #endif
diff --git a/src/stable/base64.cpp b/src/stable/base64.cpp
index 5ace999..2dc123f 100644
--- a/src/stable/base64.cpp
+++ b/src/stable/base64.cpp
@@ -10,210 +10,210 @@
 namespace Bu { subExceptionDef( Base64Exception ) }
 
 const char Bu::Base64::tblEnc[65] = {
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
 };
 
 Bu::Base64::Base64( Bu::Stream &rNext, int iChunkSize ) :
-        Bu::Filter( rNext ),
-        iBPos( 0 ),
-        iBuf( 0 ),
-        iRPos( 0 ),
-        iChars( 0 ),
-        bEosIn( false ),
-        iTotalIn( 0 ),
-        iTotalOut( 0 ),
-        eMode( Nothing ),
-        iChunkSize( iChunkSize ),
-        iCurChunk( 0 )
+    Bu::Filter( rNext ),
+    iBPos( 0 ),
+    iBuf( 0 ),
+    iRPos( 0 ),
+    iChars( 0 ),
+    bEosIn( false ),
+    iTotalIn( 0 ),
+    iTotalOut( 0 ),
+    eMode( Nothing ),
+    iChunkSize( iChunkSize ),
+    iCurChunk( 0 )
 {
-        start();
-
-        memset( tblDec, 0, 80 );
-        for( int j = 0; j < 64; j++ )
-        {
-                tblDec[tblEnc[j]-'+'] = j;
-        //      printf("'%c' = %d\n", tblEnc[j], j );
-        }
-        /*
-        for( int j = 0; j < 64; j++ )
-        {
-                printf("'%c' = '%c' (%d = %d)\n",
-                        tblEnc[j], tblEnc[tblDec[tblEnc[j]-'+']],
-                        j, tblDec[tblEnc[j]-'+'] );
-        }*/
-
-        // The following is used to compute the table size for the decoding table.
-        /*
-        char low='A', high='A';
-        for( int j = 0; j < 64; j++ )
-        {
-                if( tblEnc[j] < low )
-                        low = tblEnc[j];
-                if( tblEnc[j] > high )
-                        high = tblEnc[j];
-        }
-
-        printf("'%c' - '%c' (%d - %d) (%d)\n", low, high, low, high, high-low );
-        */
+    start();
+
+    memset( tblDec, 0, 80 );
+    for( int j = 0; j < 64; j++ )
+    {
+        tblDec[tblEnc[j]-'+'] = j;
+    //  printf("'%c' = %d\n", tblEnc[j], j );
+    }
+    /*
+    for( int j = 0; j < 64; j++ )
+    {
+        printf("'%c' = '%c' (%d = %d)\n",
+            tblEnc[j], tblEnc[tblDec[tblEnc[j]-'+']],
+            j, tblDec[tblEnc[j]-'+'] );
+    }*/
+
+    // The following is used to compute the table size for the decoding table.
+    /*
+    char low='A', high='A';
+    for( int j = 0; j < 64; j++ )
+    {
+        if( tblEnc[j] < low )
+            low = tblEnc[j];
+        if( tblEnc[j] > high )
+            high = tblEnc[j];
+    }
+
+    printf("'%c' - '%c' (%d - %d) (%d)\n", low, high, low, high, high-low );
+    */
 }
 
 Bu::Base64::~Base64()
 {
-        stop();
+    stop();
 }
 
 void Bu::Base64::start()
 {
-        iCurChunk = 0;
+    iCurChunk = 0;
 }
 
 Bu::size Bu::Base64::stop()
 {
-        if( eMode == Encode )
-        {
-                char outBuf[4];
-                int iBUsed = 4-(3-iBPos);
-                if( iBPos == 0 )
-                        return iTotalOut;
-                for( int k = 0; k < 4; k++ )
-                {
-                        outBuf[3-k] = tblEnc[(iBuf>>(6*k))&0x3f];
-                }
-                for( int k = iBUsed; k < 4; k++ )
-                {
-                        outBuf[k] = '=';
-                }
-                iCurChunk += 4;
-                if( iChunkSize && iCurChunk >= iChunkSize )
-                {
-                        iCurChunk = iCurChunk-iChunkSize;
-                        iTotalOut += rNext.write( outBuf, 4-iCurChunk );
-                        iTotalOut += rNext.write("\r\n", 2 );
-                        iTotalOut += rNext.write( outBuf+(4-iCurChunk), iCurChunk );
-                }
-                else
-                        iTotalOut += rNext.write( outBuf, 4 );
-                return iTotalOut;
-        }
-        else
-        {
-                return iTotalIn;
-        }
+    if( eMode == Encode )
+    {
+        char outBuf[4];
+        int iBUsed = 4-(3-iBPos);
+        if( iBPos == 0 )
+            return iTotalOut;
+        for( int k = 0; k < 4; k++ )
+        {
+            outBuf[3-k] = tblEnc[(iBuf>>(6*k))&0x3f];
+        }
+        for( int k = iBUsed; k < 4; k++ )
+        {
+            outBuf[k] = '=';
+        }
+        iCurChunk += 4;
+        if( iChunkSize && iCurChunk >= iChunkSize )
+        {
+            iCurChunk = iCurChunk-iChunkSize;
+            iTotalOut += rNext.write( outBuf, 4-iCurChunk );
+            iTotalOut += rNext.write("\r\n", 2 );
+            iTotalOut += rNext.write( outBuf+(4-iCurChunk), iCurChunk );
+        }
+        else
+            iTotalOut += rNext.write( outBuf, 4 );
+        return iTotalOut;
+    }
+    else
+    {
+        return iTotalIn;
+    }
 }
 
 Bu::size Bu::Base64::read( void *pBuf, Bu::size nBytes )
 {
-        if( eMode == Encode )
-                throw Bu::Base64Exception("Cannot read from an output stream.");
-        eMode = Decode;
-
-        if( bEosIn == true && iRPos == iChars )
-                return 0;
-        Bu::size sIn = 0;
-        char buf[4];
-        while( sIn < nBytes )
-        {
-                for(; iRPos < iChars && sIn < nBytes; iRPos++, sIn++ )
-                {
-                        ((unsigned char *)pBuf)[sIn] = (iBuf>>(8*(2-iRPos)))&0xFF;
-                }
-                if( iRPos == iChars )
-                {
-                        if( bEosIn == true )
-                                return sIn;
-                        else
-                                iRPos = 0;
-                }
-                else if( sIn == nBytes )
-                        return sIn;
-                //if( rNext.read( buf, 4 ) == 0 )
-                //      return sIn;
-                for( int j = 0; j < 4; j++ )
-                {
-                        if( rNext.read( &buf[j], 1 ) == 0 )
-                        {
-                                if( rNext.isEos() )
-                                {
-                                        if( iRPos == 0 )
-                                                iRPos = iChars;
-                                        bEosIn = true;
-                                        if( j != 0 )
-                                        {
-                                                throw Base64Exception(
-                                                        "Premature end of stream detected while "
-                                                        "decoding Base64 data."
-                                                        );
-                                        }
-                                }
-                                return sIn;
-                        }
-                        if( buf[j] == ' ' || buf[j] == '\t' ||
-                                buf[j] == '\n' || buf[j] == '\r' )
-                        {
-                                j--;
-                        }
-                }
-                iChars = 3;
-                iBuf = 0;
-                for( int j = 0; j < 4; j++ )
-                {
-                        if( buf[j] == '=' )
-                        {
-                                iChars--;
-                                bEosIn = true;
-                        }
-                        else
-                                iBuf |= (tblDec[buf[j]-'+']&0x3f)<<((3-j)*6);
-                        //printf("%d:  %06X (%02X)\n", j, iBuf, (tblDec[buf[j]-'+']&0x3f) );
-                }
-        }
-
-        return sIn;
+    if( eMode == Encode )
+        throw Bu::Base64Exception("Cannot read from an output stream.");
+    eMode = Decode;
+
+    if( bEosIn == true && iRPos == iChars )
+        return 0;
+    Bu::size sIn = 0;
+    char buf[4];
+    while( sIn < nBytes )
+    {
+        for(; iRPos < iChars && sIn < nBytes; iRPos++, sIn++ )
+        {
+            ((unsigned char *)pBuf)[sIn] = (iBuf>>(8*(2-iRPos)))&0xFF;
+        }
+        if( iRPos == iChars )
+        {
+            if( bEosIn == true )
+                return sIn;
+            else
+                iRPos = 0;
+        }
+        else if( sIn == nBytes )
+            return sIn;
+        //if( rNext.read( buf, 4 ) == 0 )
+        //  return sIn;
+        for( int j = 0; j < 4; j++ )
+        {
+            if( rNext.read( &buf[j], 1 ) == 0 )
+            {
+                if( rNext.isEos() )
+                {
+                    if( iRPos == 0 )
+                        iRPos = iChars;
+                    bEosIn = true;
+                    if( j != 0 )
+                    {
+                        throw Base64Exception(
+                            "Premature end of stream detected while "
+                            "decoding Base64 data."
+                            );
+                    }
+                }
+                return sIn;
+            }
+            if( buf[j] == ' ' || buf[j] == '\t' ||
+                buf[j] == '\n' || buf[j] == '\r' )
+            {
+                j--;
+            }
+        }
+        iChars = 3;
+        iBuf = 0;
+        for( int j = 0; j < 4; j++ )
+        {
+            if( buf[j] == '=' )
+            {
+                iChars--;
+                bEosIn = true;
+            }
+            else
+                iBuf |= (tblDec[buf[j]-'+']&0x3f)<<((3-j)*6);
+            //printf("%d:  %06X (%02X)\n", j, iBuf, (tblDec[buf[j]-'+']&0x3f) );
+        }
+    }
+
+    return sIn;
 }
 
 Bu::size Bu::Base64::write( const void *pBuf, Bu::size nBytes )
 {
-        if( eMode == Decode )
-                throw Bu::Base64Exception("Cannot write to an input stream.");
-        eMode = Encode;
-
-        Bu::size sOut = 0;
-        char outBuf[4];
-        for( Bu::size j = 0; j < nBytes; j++ )
-        {
-                iBuf |= (((uint8_t *)pBuf)[j])<<((2-iBPos++)*8);
-                if( iBPos == 3 )
-                {
-                        for( int k = 0; k < 4; k++ )
-                        {
-                                outBuf[3-k] = tblEnc[(iBuf>>(6*k))&0x3f];
-                        }
-                        iCurChunk += 4;
-                        if( iChunkSize && iCurChunk >= iChunkSize )
-                        {
-                                iCurChunk = iCurChunk-iChunkSize;
-                                sOut += rNext.write( outBuf, 4-iCurChunk );
-                                sOut += rNext.write("\r\n", 2 );
-                                sOut += rNext.write( outBuf+(4-iCurChunk), iCurChunk );
-                        }
-                        else
-                                sOut += rNext.write( outBuf, 4 );
-                        iBPos = iBuf = 0;
-                }
-        }
-        iTotalOut += sOut;
-        return sOut;
+    if( eMode == Decode )
+        throw Bu::Base64Exception("Cannot write to an input stream.");
+    eMode = Encode;
+
+    Bu::size sOut = 0;
+    char outBuf[4];
+    for( Bu::size j = 0; j < nBytes; j++ )
+    {
+        iBuf |= (((uint8_t *)pBuf)[j])<<((2-iBPos++)*8);
+        if( iBPos == 3 )
+        {
+            for( int k = 0; k < 4; k++ )
+            {
+                outBuf[3-k] = tblEnc[(iBuf>>(6*k))&0x3f];
+            }
+            iCurChunk += 4;
+            if( iChunkSize && iCurChunk >= iChunkSize )
+            {
+                iCurChunk = iCurChunk-iChunkSize;
+                sOut += rNext.write( outBuf, 4-iCurChunk );
+                sOut += rNext.write("\r\n", 2 );
+                sOut += rNext.write( outBuf+(4-iCurChunk), iCurChunk );
+            }
+            else
+                sOut += rNext.write( outBuf, 4 );
+            iBPos = iBuf = 0;
+        }
+    }
+    iTotalOut += sOut;
+    return sOut;
 }
 
 bool Bu::Base64::isOpen()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Base64::isEos()
 {
-        if( bEosIn == true && iRPos == iChars )
-                return true;
-        return false;
+    if( bEosIn == true && iRPos == iChars )
+        return true;
+    return false;
 }
 
diff --git a/src/stable/base64.h b/src/stable/base64.h
index b10aaeb..695a5ea 100644
--- a/src/stable/base64.h
+++ b/src/stable/base64.h
@@ -13,47 +13,47 @@
 
 namespace Bu
 {
-        subExceptionDecl( Base64Exception );
-        
-        /**
-         *
-         *@ingroup Streams
-         */
-        class Base64 : public Bu::Filter
-        {
-        public:
-                Base64( Bu::Stream &rNext, int iChunkSize=0 );
-                virtual ~Base64();
-
-                virtual void start();
-                virtual Bu::size stop();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-
-                virtual bool isOpen();
-
-                virtual bool isEos();
-
-        private:
-                int iBPos;
-                int iBuf;
-                int iRPos;
-                int iChars;
-                bool bEosIn;
-                Bu::size iTotalIn;
-                Bu::size iTotalOut;
-                static const char tblEnc[65];
-                char tblDec[80];
-                enum Mode
-                {
-                        Nothing         = 0x00,
-                        Encode          = 0x01,
-                        Decode          = 0x02,
-                };
-                Mode eMode;
-                int iChunkSize;
-                int iCurChunk;
-        };
+    subExceptionDecl( Base64Exception );
+    
+    /**
+     *
+     *@ingroup Streams
+     */
+    class Base64 : public Bu::Filter
+    {
+    public:
+        Base64( Bu::Stream &rNext, int iChunkSize=0 );
+        virtual ~Base64();
+
+        virtual void start();
+        virtual Bu::size stop();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+        virtual bool isOpen();
+
+        virtual bool isEos();
+
+    private:
+        int iBPos;
+        int iBuf;
+        int iRPos;
+        int iChars;
+        bool bEosIn;
+        Bu::size iTotalIn;
+        Bu::size iTotalOut;
+        static const char tblEnc[65];
+        char tblDec[80];
+        enum Mode
+        {
+            Nothing     = 0x00,
+            Encode      = 0x01,
+            Decode      = 0x02,
+        };
+        Mode eMode;
+        int iChunkSize;
+        int iCurChunk;
+    };
 };
 
 #endif
diff --git a/src/stable/buffer.cpp b/src/stable/buffer.cpp
index 16c3e2f..c787499 100644
--- a/src/stable/buffer.cpp
+++ b/src/stable/buffer.cpp
@@ -8,26 +8,26 @@
 #include "bu/buffer.h"
 
 Bu::Buffer::Buffer( Bu::Stream &rNext, int iWhat, int iBufSize ) :
-        Bu::Filter( rNext ),
-        sSoFar( 0 ),
-        iBufSize( iBufSize ),
-        sReadBuf( NULL ),
-        sWriteBuf( NULL ),
-        iReadBufFill( 0 ),
-        iReadPos( 0 ),
-        iWriteBufFill( 0 ),
-        iWritePos( 0 ),
-        iWhat( iWhat )
+    Bu::Filter( rNext ),
+    sSoFar( 0 ),
+    iBufSize( iBufSize ),
+    sReadBuf( NULL ),
+    sWriteBuf( NULL ),
+    iReadBufFill( 0 ),
+    iReadPos( 0 ),
+    iWriteBufFill( 0 ),
+    iWritePos( 0 ),
+    iWhat( iWhat )
 {
-        sReadBuf = new char[iBufSize];
-        sWriteBuf = new char[iBufSize];
+    sReadBuf = new char[iBufSize];
+    sWriteBuf = new char[iBufSize];
 }
 
 Bu::Buffer::~Buffer()
 {
-        flush();
-        delete[] sReadBuf;
-        delete[] sWriteBuf;
+    flush();
+    delete[] sReadBuf;
+    delete[] sWriteBuf;
 }
 
 void Bu::Buffer::start()
@@ -36,135 +36,135 @@ void Bu::Buffer::start()
 
 Bu::size Bu::Buffer::stop()
 {
-        flush();
-        iReadBufFill = iReadPos = iWriteBufFill = iWritePos = 0;
-        return sSoFar;
+    flush();
+    iReadBufFill = iReadPos = iWriteBufFill = iWritePos = 0;
+    return sSoFar;
 }
 
 void Bu::Buffer::fillReadBuf()
 {
-        if( iReadBufFill+iReadPos < iBufSize )
-        {
-                iReadBufFill += rNext.read(
-                        sReadBuf+iReadPos+iReadBufFill,
-                        iBufSize-iReadBufFill-iReadPos
-                        );
-        }
+    if( iReadBufFill+iReadPos < iBufSize )
+    {
+        iReadBufFill += rNext.read(
+            sReadBuf+iReadPos+iReadBufFill,
+            iBufSize-iReadBufFill-iReadPos
+            );
+    }
 }
 
 Bu::size Bu::Buffer::read( void *pBuf, Bu::size nBytes )
 {
-        if( (iWhat&Read) == 0 )
-                return rNext.read( pBuf, nBytes );
-
-        if( nBytes <= 0 )
-        {
-                fillReadBuf();
-                return 0;
-        }
-
-        Bu::size nTotRead = 0;
-//      fillReadBuf();
-
-        do
-        {
-                int iAmnt = nBytes-nTotRead;
-                if( iAmnt > iReadBufFill )
-                {
-                        iAmnt = iReadBufFill;
-                }
-                if( iAmnt > 0 )
-                {
-                        memcpy( ((char *)pBuf)+nTotRead, sReadBuf+iReadPos, iAmnt );
-                        iReadPos += iAmnt;
-                        nTotRead += iAmnt;
-                        iReadBufFill -= iAmnt;
-                }
-                if( iReadBufFill == 0 )
-                {
-                        iReadPos = 0;
-                        fillReadBuf();
-                }
-        }
-        while( nTotRead < nBytes && iReadBufFill > 0 );
-
-        //printf("Buffer:  %db returned, %db remain in buffer.\n", nTotRead, iReadBufFill );
-
-        return nTotRead;
+    if( (iWhat&Read) == 0 )
+        return rNext.read( pBuf, nBytes );
+
+    if( nBytes <= 0 )
+    {
+        fillReadBuf();
+        return 0;
+    }
+
+    Bu::size nTotRead = 0;
+//  fillReadBuf();
+
+    do
+    {
+        int iAmnt = nBytes-nTotRead;
+        if( iAmnt > iReadBufFill )
+        {
+            iAmnt = iReadBufFill;
+        }
+        if( iAmnt > 0 )
+        {
+            memcpy( ((char *)pBuf)+nTotRead, sReadBuf+iReadPos, iAmnt );
+            iReadPos += iAmnt;
+            nTotRead += iAmnt;
+            iReadBufFill -= iAmnt;
+        }
+        if( iReadBufFill == 0 )
+        {
+            iReadPos = 0;
+            fillReadBuf();
+        }
+    }
+    while( nTotRead < nBytes && iReadBufFill > 0 );
+
+    //printf("Buffer:  %db returned, %db remain in buffer.\n", nTotRead, iReadBufFill );
+
+    return nTotRead;
 }
 
 Bu::size Bu::Buffer::write( const void *pBuf, Bu::size nBytes )
 {
-        if( (iWhat&Write) == 0 )
-                return rNext.write( pBuf, nBytes );
-
-        Bu::size nTotWrote = 0;
-
-        do
-        {
-                int iAmnt = nBytes-nTotWrote;
-                if( iAmnt > iBufSize-iWritePos-iWriteBufFill )
-                {
-                        iAmnt = iBufSize-iWritePos-iWriteBufFill;
-                }
-                if( iAmnt > 0 )
-                {
-                        memcpy(
-                                sWriteBuf+iWritePos+iWriteBufFill,
-                                ((char *)pBuf)+nTotWrote,
-                                iAmnt
-                                );
-                        nTotWrote += iAmnt;
-                        iWriteBufFill += iAmnt;
-                        //printf("Buffer: Moved %db to write buffer, %db filled now.\n",
-                                        //iAmnt, iWriteBufFill );
-                }
-                while( iWritePos+iWriteBufFill == iBufSize )
-                {
-                        //printf("iWritePos = %d\n", iWritePos );
-                        int iWr = rNext.write( sWriteBuf+iWritePos, iWriteBufFill );
-                        //printf("Buffer: Wrote %db from buffer to stream, %db filled now.\n", iWr, iWriteBufFill-iWr );
-                        if( iWr == 0 )
-                        {
-                                return nTotWrote;
-                        }
-                        else if( iWr == iWriteBufFill )
-                        {
-                                iWritePos = iWriteBufFill = 0;
-                        }
-                        else
-                        {
-                                iWritePos += iWr;
-                                iWriteBufFill -= iWr;
-                        }
-                }
-        }
-        while( nTotWrote < nBytes && iWriteBufFill < iBufSize+iWritePos );
-
-        return nTotWrote;
+    if( (iWhat&Write) == 0 )
+        return rNext.write( pBuf, nBytes );
+
+    Bu::size nTotWrote = 0;
+
+    do
+    {
+        int iAmnt = nBytes-nTotWrote;
+        if( iAmnt > iBufSize-iWritePos-iWriteBufFill )
+        {
+            iAmnt = iBufSize-iWritePos-iWriteBufFill;
+        }
+        if( iAmnt > 0 )
+        {
+            memcpy(
+                sWriteBuf+iWritePos+iWriteBufFill,
+                ((char *)pBuf)+nTotWrote,
+                iAmnt
+                );
+            nTotWrote += iAmnt;
+            iWriteBufFill += iAmnt;
+            //printf("Buffer: Moved %db to write buffer, %db filled now.\n",
+                    //iAmnt, iWriteBufFill );
+        }
+        while( iWritePos+iWriteBufFill == iBufSize )
+        {
+            //printf("iWritePos = %d\n", iWritePos );
+            int iWr = rNext.write( sWriteBuf+iWritePos, iWriteBufFill );
+            //printf("Buffer: Wrote %db from buffer to stream, %db filled now.\n", iWr, iWriteBufFill-iWr );
+            if( iWr == 0 )
+            {
+                return nTotWrote;
+            }
+            else if( iWr == iWriteBufFill )
+            {
+                iWritePos = iWriteBufFill = 0;
+            }
+            else
+            {
+                iWritePos += iWr;
+                iWriteBufFill -= iWr;
+            }
+        }
+    }
+    while( nTotWrote < nBytes && iWriteBufFill < iBufSize+iWritePos );
+
+    return nTotWrote;
 }
 
 void Bu::Buffer::flush()
 {
-        if( (iWhat&Write) == 0 )
-                return rNext.flush();
-
-        if( iWriteBufFill > 0 )
-        {
-                //printf("Buffer: Flushing remaining data, %db.\n", iWriteBufFill );
-                int iWr = 0;
-                do
-                {
-                        iWr = rNext.write( sWriteBuf+iWritePos, iWriteBufFill );
-                        //printf("Buffer: %db written to stream.\n", iWr );
-                        iWritePos += iWr;
-                        iWriteBufFill -= iWr;
-                } while( iWriteBufFill > 0 && iWr > 0 );
-        }
+    if( (iWhat&Write) == 0 )
+        return rNext.flush();
+
+    if( iWriteBufFill > 0 )
+    {
+        //printf("Buffer: Flushing remaining data, %db.\n", iWriteBufFill );
+        int iWr = 0;
+        do
+        {
+            iWr = rNext.write( sWriteBuf+iWritePos, iWriteBufFill );
+            //printf("Buffer: %db written to stream.\n", iWr );
+            iWritePos += iWr;
+            iWriteBufFill -= iWr;
+        } while( iWriteBufFill > 0 && iWr > 0 );
+    }
 }
 
 bool Bu::Buffer::isEos()
 {
-        return (iReadPos >= (iReadBufFill-1)) && (rNext.isEos());
+    return (iReadPos >= (iReadBufFill-1)) && (rNext.isEos());
 }
 
diff --git a/src/stable/buffer.h b/src/stable/buffer.h
index a8303fa..21a5812 100644
--- a/src/stable/buffer.h
+++ b/src/stable/buffer.h
@@ -12,47 +12,47 @@
 
 namespace Bu
 {
-        class Buffer : public Bu::Filter
-        {
-        public:
-                Buffer( Bu::Stream &rNext, int iWhat=Both, int iBufSize=4096 );
-                virtual ~Buffer();
-
-                enum
-                {
-                        Write   = 1,
-                        Read    = 2,
-                        Both    = 3
-                };
-
-                virtual void start();
-                virtual Bu::size stop();
-
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
-
-                Bu::size getReadFill() { return iReadBufFill; }
-                bool isWritePending() { return iWriteBufFill > 0; }
-
-                virtual void flush();
-
-                virtual bool isEos();
-
-        private:
-                void fillReadBuf();
-
-        private:
-                Bu::size sSoFar;
-                int iBufSize;
-                char *sReadBuf;
-                char *sWriteBuf;
-                int iReadBufFill;
-                int iReadPos;
-                int iWriteBufFill;
-                int iWritePos;
-                int iWhat;
-        };
+    class Buffer : public Bu::Filter
+    {
+    public:
+        Buffer( Bu::Stream &rNext, int iWhat=Both, int iBufSize=4096 );
+        virtual ~Buffer();
+
+        enum
+        {
+            Write   = 1,
+            Read    = 2,
+            Both    = 3
+        };
+
+        virtual void start();
+        virtual Bu::size stop();
+
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
+
+        Bu::size getReadFill() { return iReadBufFill; }
+        bool isWritePending() { return iWriteBufFill > 0; }
+
+        virtual void flush();
+
+        virtual bool isEos();
+
+    private:
+        void fillReadBuf();
+
+    private:
+        Bu::size sSoFar;
+        int iBufSize;
+        char *sReadBuf;
+        char *sWriteBuf;
+        int iReadBufFill;
+        int iReadPos;
+        int iWriteBufFill;
+        int iWritePos;
+        int iWhat;
+    };
 };
 
 #endif
diff --git a/src/stable/bzip2.cpp b/src/stable/bzip2.cpp
index 11b8873..5e660d0 100644
--- a/src/stable/bzip2.cpp
+++ b/src/stable/bzip2.cpp
@@ -15,222 +15,222 @@
 using namespace Bu;
 
 Bu::BZip2::BZip2( Bu::Stream &rNext, int nCompression ) :
-        Bu::Filter( rNext ),
-        prState( NULL ),
-        nCompression( nCompression ),
-        sTotalOut( 0 )
+    Bu::Filter( rNext ),
+    prState( NULL ),
+    nCompression( nCompression ),
+    sTotalOut( 0 )
 {
-        TRACE( nCompression );
-        start();
+    TRACE( nCompression );
+    start();
 }
 
 Bu::BZip2::~BZip2()
 {
-        TRACE();
-        stop();
+    TRACE();
+    stop();
 }
 
 void Bu::BZip2::start()
 {
-        TRACE();
+    TRACE();
 
-        prState = new bz_stream;
-        pState->state = NULL;
-        pState->bzalloc = NULL;
-        pState->bzfree = NULL;
-        pState->opaque = NULL;
+    prState = new bz_stream;
+    pState->state = NULL;
+    pState->bzalloc = NULL;
+    pState->bzfree = NULL;
+    pState->opaque = NULL;
 
-        nBufSize = 64*1024;
-        pBuf = new char[nBufSize];
+    nBufSize = 64*1024;
+    pBuf = new char[nBufSize];
 }
 
 Bu::size Bu::BZip2::stop()
 {
-        TRACE();
-        if( !pState )
-                return 0;
-
-        if( pState->state )
-        {
-                if( bReading )
-                {
-                        BZ2_bzDecompressEnd( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return 0;
-                }
-                else
-                {
-//                      Bu::size sTotal = 0;
-                        for(;;)
-                        {
-                                pState->next_in = NULL;
-                                pState->avail_in = 0;
-                                pState->avail_out = nBufSize;
-                                pState->next_out = pBuf;
-                                int res = BZ2_bzCompress( pState, BZ_FINISH );
-                                if( pState->avail_out < nBufSize )
-                                {
-                                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                                }
-                                if( res == BZ_STREAM_END )
-                                        break;
-                        }
-                        BZ2_bzCompressEnd( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return sTotalOut;
-                }
-        }
-        return 0;
+    TRACE();
+    if( !pState )
+        return 0;
+
+    if( pState->state )
+    {
+        if( bReading )
+        {
+            BZ2_bzDecompressEnd( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return 0;
+        }
+        else
+        {
+//          Bu::size sTotal = 0;
+            for(;;)
+            {
+                pState->next_in = NULL;
+                pState->avail_in = 0;
+                pState->avail_out = nBufSize;
+                pState->next_out = pBuf;
+                int res = BZ2_bzCompress( pState, BZ_FINISH );
+                if( pState->avail_out < nBufSize )
+                {
+                    sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                }
+                if( res == BZ_STREAM_END )
+                    break;
+            }
+            BZ2_bzCompressEnd( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return sTotalOut;
+        }
+    }
+    return 0;
 }
 
 void Bu::BZip2::bzError( int code )
 {
-        TRACE( code );
-        switch( code )
-        {
-                case BZ_OK:
-                case BZ_RUN_OK:
-                case BZ_FLUSH_OK:
-                case BZ_FINISH_OK:
-                        return;
+    TRACE( code );
+    switch( code )
+    {
+        case BZ_OK:
+        case BZ_RUN_OK:
+        case BZ_FLUSH_OK:
+        case BZ_FINISH_OK:
+            return;
 
-                case BZ_CONFIG_ERROR:
-                        throw ExceptionBase("BZip2: Library configured improperly, reinstall.");
+        case BZ_CONFIG_ERROR:
+            throw ExceptionBase("BZip2: Library configured improperly, reinstall.");
 
-                case BZ_SEQUENCE_ERROR:
-                        throw ExceptionBase("BZip2: Functions were called in an invalid sequence.");
+        case BZ_SEQUENCE_ERROR:
+            throw ExceptionBase("BZip2: Functions were called in an invalid sequence.");
 
-                case BZ_PARAM_ERROR:
-                        throw ExceptionBase("BZip2: Invalid parameter was passed into a function.");
+        case BZ_PARAM_ERROR:
+            throw ExceptionBase("BZip2: Invalid parameter was passed into a function.");
 
-                case BZ_MEM_ERROR:
-                        throw ExceptionBase("BZip2: Couldn't allocate sufficient memory.");
+        case BZ_MEM_ERROR:
+            throw ExceptionBase("BZip2: Couldn't allocate sufficient memory.");
 
-                case BZ_DATA_ERROR:
-                        throw ExceptionBase("BZip2: Data was corrupted before decompression.");
+        case BZ_DATA_ERROR:
+            throw ExceptionBase("BZip2: Data was corrupted before decompression.");
 
-                case BZ_DATA_ERROR_MAGIC:
-                        throw ExceptionBase("BZip2: Stream does not appear to be bzip2 data.");
+        case BZ_DATA_ERROR_MAGIC:
+            throw ExceptionBase("BZip2: Stream does not appear to be bzip2 data.");
 
-                case BZ_IO_ERROR:
-                        throw ExceptionBase("BZip2: File couldn't be read from / written to.");
+        case BZ_IO_ERROR:
+            throw ExceptionBase("BZip2: File couldn't be read from / written to.");
 
-                case BZ_UNEXPECTED_EOF:
-                        throw ExceptionBase("BZip2: End of file encountered before end of stream.");
+        case BZ_UNEXPECTED_EOF:
+            throw ExceptionBase("BZip2: End of file encountered before end of stream.");
 
-                case BZ_OUTBUFF_FULL:
-                        throw ExceptionBase("BZip2: Buffer not large enough to accomidate data.");
+        case BZ_OUTBUFF_FULL:
+            throw ExceptionBase("BZip2: Buffer not large enough to accomidate data.");
 
-                default:
-                        throw ExceptionBase("BZip2: Unknown error encountered.");
-        
-        }
+        default:
+            throw ExceptionBase("BZip2: Unknown error encountered.");
+    
+    }
 }
 
 Bu::size Bu::BZip2::read( void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( !pState->state )
-        {
-                bReading = true;
-                BZ2_bzDecompressInit( pState, 0, 0 );
-                pState->next_in = pBuf;
-                pState->avail_in = 0;
-        }
-        if( bReading == false )
-                throw ExceptionBase("This bzip2 filter is in writing mode, you can't read.");
-
-        int nRead = 0;
-        int nReadTotal = pState->total_out_lo32;
-        pState->next_out = (char *)pData;
-        pState->avail_out = nBytes;
-        for(;;)
-        {
-                int ret = BZ2_bzDecompress( pState );
-        
-                nReadTotal += nRead-pState->avail_out;
-
-                if( ret == BZ_STREAM_END )
-                {
-                        if( pState->avail_in > 0 )
-                        {
-                                if( rNext.isSeekable() )
-                                {
-                                        rNext.seek( -(Bu::size)pState->avail_in );
-                                }
-                        }
-                        return nBytes-pState->avail_out;
-                }
-                bzError( ret );
-
-                if( pState->avail_out )
-                {
-                        if( pState->avail_in == 0 )
-                        {
-                                nRead = rNext.read( pBuf, nBufSize );
-                                if( nRead == 0 && rNext.isEos() )
-                                {
-                                        throw Bu::ExceptionBase("Premature end of underlying "
-                                                        "stream found reading bzip2 stream.");
-                                }
-                                pState->next_in = pBuf;
-                                pState->avail_in = nRead;
-                        }
-                }
-                else
-                {
-                        return nBytes-pState->avail_out;
-                }
-        }
-        return 0;
+    TRACE( pData, nBytes );
+    if( !pState->state )
+    {
+        bReading = true;
+        BZ2_bzDecompressInit( pState, 0, 0 );
+        pState->next_in = pBuf;
+        pState->avail_in = 0;
+    }
+    if( bReading == false )
+        throw ExceptionBase("This bzip2 filter is in writing mode, you can't read.");
+
+    int nRead = 0;
+    int nReadTotal = pState->total_out_lo32;
+    pState->next_out = (char *)pData;
+    pState->avail_out = nBytes;
+    for(;;)
+    {
+        int ret = BZ2_bzDecompress( pState );
+    
+        nReadTotal += nRead-pState->avail_out;
+
+        if( ret == BZ_STREAM_END )
+        {
+            if( pState->avail_in > 0 )
+            {
+                if( rNext.isSeekable() )
+                {
+                    rNext.seek( -(Bu::size)pState->avail_in );
+                }
+            }
+            return nBytes-pState->avail_out;
+        }
+        bzError( ret );
+
+        if( pState->avail_out )
+        {
+            if( pState->avail_in == 0 )
+            {
+                nRead = rNext.read( pBuf, nBufSize );
+                if( nRead == 0 && rNext.isEos() )
+                {
+                    throw Bu::ExceptionBase("Premature end of underlying "
+                            "stream found reading bzip2 stream.");
+                }
+                pState->next_in = pBuf;
+                pState->avail_in = nRead;
+            }
+        }
+        else
+        {
+            return nBytes-pState->avail_out;
+        }
+    }
+    return 0;
 }
 
 Bu::size Bu::BZip2::write( const void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( !pState->state )
-        {
-                bReading = false;
-                BZ2_bzCompressInit( pState, nCompression, 0, 30 );
-        }
-        if( bReading == true )
-                throw ExceptionBase("This bzip2 filter is in reading mode, you can't write.");
-
-//      Bu::size sTotalOut = 0;
-        pState->next_in = (char *)pData;
-        pState->avail_in = nBytes;
-        for(;;)
-        {
-                pState->avail_out = nBufSize;
-                pState->next_out = pBuf;
-
-                bzError( BZ2_bzCompress( pState, BZ_RUN ) );
-
-                if( pState->avail_out < nBufSize )
-                {
-                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                }
-                if( pState->avail_in == 0 )
-                        break;
-        }
-
-        return nBytes;
+    TRACE( pData, nBytes );
+    if( !pState->state )
+    {
+        bReading = false;
+        BZ2_bzCompressInit( pState, nCompression, 0, 30 );
+    }
+    if( bReading == true )
+        throw ExceptionBase("This bzip2 filter is in reading mode, you can't write.");
+
+//  Bu::size sTotalOut = 0;
+    pState->next_in = (char *)pData;
+    pState->avail_in = nBytes;
+    for(;;)
+    {
+        pState->avail_out = nBufSize;
+        pState->next_out = pBuf;
+
+        bzError( BZ2_bzCompress( pState, BZ_RUN ) );
+
+        if( pState->avail_out < nBufSize )
+        {
+            sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+        }
+        if( pState->avail_in == 0 )
+            break;
+    }
+
+    return nBytes;
 }
 
 bool Bu::BZip2::isOpen()
 {
-        TRACE();
-        return (pState->state != NULL);
+    TRACE();
+    return (pState->state != NULL);
 }
 
 Bu::size Bu::BZip2::getCompressedSize()
 {
-        return sTotalOut;
+    return sTotalOut;
 }
 
diff --git a/src/stable/bzip2.h b/src/stable/bzip2.h
index d92dd2f..d53f325 100644
--- a/src/stable/bzip2.h
+++ b/src/stable/bzip2.h
@@ -14,36 +14,36 @@
 
 namespace Bu
 {
-        /**
-         * Provides BZip2 type compression and decompression.
-         *
-         *@ingroup Streams
-         *@ingroup Compression
-         */
-        class BZip2 : public Bu::Filter
-        {
-        public:
-                BZip2( Bu::Stream &rNext, int nCompression=9 );
-                virtual ~BZip2();
-
-                virtual void start();
-                virtual Bu::size stop();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-
-                virtual bool isOpen();
-
-                Bu::size getCompressedSize();
-
-        private:
-                void bzError( int code );
-                void *prState;
-                bool bReading;
-                int nCompression;
-                char *pBuf;
-                uint32_t nBufSize;
-                Bu::size sTotalOut;
-        };
+    /**
+     * Provides BZip2 type compression and decompression.
+     *
+     *@ingroup Streams
+     *@ingroup Compression
+     */
+    class BZip2 : public Bu::Filter
+    {
+    public:
+        BZip2( Bu::Stream &rNext, int nCompression=9 );
+        virtual ~BZip2();
+
+        virtual void start();
+        virtual Bu::size stop();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+        virtual bool isOpen();
+
+        Bu::size getCompressedSize();
+
+    private:
+        void bzError( int code );
+        void *prState;
+        bool bReading;
+        int nCompression;
+        char *pBuf;
+        uint32_t nBufSize;
+        Bu::size sTotalOut;
+    };
 }
 
 #endif
diff --git a/src/stable/client.cpp b/src/stable/client.cpp
index 7ae10f7..f5cc75f 100644
--- a/src/stable/client.cpp
+++ b/src/stable/client.cpp
@@ -14,307 +14,307 @@
 #include "bu/clientlinkfactory.h"
 
 /** Read buffer size. */
-#define RBS             (2000) // 1500 is the nominal MTU for ethernet, it's a good guess
+#define RBS     (2000) // 1500 is the nominal MTU for ethernet, it's a good guess
 
 Bu::Client::Client( Bu::TcpSocket *pSocket,
-                class Bu::ClientLinkFactory *pfLink ) :
-        pTopStream( pSocket ),
-        pSocket( pSocket ),
-        pProto( NULL ),
-        bWantsDisconnect( false ),
-        pfLink( pfLink )
+        class Bu::ClientLinkFactory *pfLink ) :
+    pTopStream( pSocket ),
+    pSocket( pSocket ),
+    pProto( NULL ),
+    bWantsDisconnect( false ),
+    pfLink( pfLink )
 {
-        lFilts.prepend( pSocket );
+    lFilts.prepend( pSocket );
 }
 
 Bu::Client::~Client()
 {
-        for( FilterList::iterator i = lFilts.begin(); i; i++ )
-        {
-                delete *i;
-        }
-        pTopStream = pSocket = NULL;
-        delete pfLink;
+    for( FilterList::iterator i = lFilts.begin(); i; i++ )
+    {
+        delete *i;
+    }
+    pTopStream = pSocket = NULL;
+    delete pfLink;
 }
 
 void Bu::Client::processInput()
 {
-        char buf[RBS];
-        Bu::size nRead, nTotal=0;
-
-        for(;;)
-        {
-                try
-                {
-                        nRead = pTopStream->read( buf, RBS );
-
-                        if( nRead == 0 )
-                        {
-                                break;
-                        }
-                        else
-                        {
-                                nTotal += nRead;
-                                qbRead.write( buf, nRead );
-                                if( !pTopStream->canRead() )
-                                        break;
-                        }
-                }
-                catch( Bu::TcpSocketException &e )
-                {
-                        pTopStream->close();
-                        bWantsDisconnect = true;
-                        break;
-                }
-        }
-
-        if( nTotal == 0 )
-        {
-                pTopStream->close();
-                bWantsDisconnect = true;
-        }
-
-        if( pProto && nTotal )
-        {
-                pProto->onNewData( this );
-        }
+    char buf[RBS];
+    Bu::size nRead, nTotal=0;
+
+    for(;;)
+    {
+        try
+        {
+            nRead = pTopStream->read( buf, RBS );
+
+            if( nRead == 0 )
+            {
+                break;
+            }
+            else
+            {
+                nTotal += nRead;
+                qbRead.write( buf, nRead );
+                if( !pTopStream->canRead() )
+                    break;
+            }
+        }
+        catch( Bu::TcpSocketException &e )
+        {
+            pTopStream->close();
+            bWantsDisconnect = true;
+            break;
+        }
+    }
+
+    if( nTotal == 0 )
+    {
+        pTopStream->close();
+        bWantsDisconnect = true;
+    }
+
+    if( pProto && nTotal )
+    {
+        pProto->onNewData( this );
+    }
 }
 
 void Bu::Client::processOutput()
 {
-        char buf[RBS];
-        if( qbWrite.getSize() > 0 )
-        {
-                int nAmnt = RBS;
-                nAmnt = qbWrite.peek( buf, nAmnt );
-                int nReal = pTopStream->write( buf, nAmnt );
-                qbWrite.seek( nReal );
-                pTopStream->flush();
-        }
+    char buf[RBS];
+    if( qbWrite.getSize() > 0 )
+    {
+        int nAmnt = RBS;
+        nAmnt = qbWrite.peek( buf, nAmnt );
+        int nReal = pTopStream->write( buf, nAmnt );
+        qbWrite.seek( nReal );
+        pTopStream->flush();
+    }
 }
 
 void Bu::Client::setProtocol( Protocol *pProto )
 {
-        this->pProto = pProto;
-        this->pProto->onNewConnection( this );
+    this->pProto = pProto;
+    this->pProto->onNewConnection( this );
 }
 
 Bu::Protocol *Bu::Client::getProtocol()
 {
-        return pProto;
+    return pProto;
 }
 
 void Bu::Client::clearProtocol()
 {
-        pProto = NULL;
+    pProto = NULL;
 }
 /*
 Bu::String &Bu::Client::getInput()
 {
-        return sReadBuf;
+    return sReadBuf;
 }
 
 Bu::String &Bu::Client::getOutput()
 {
-        return sWriteBuf;
+    return sWriteBuf;
 }
 */
 
 bool Bu::Client::isOpen()
 {
-        if( !pTopStream ) return false;
-        return pTopStream->isOpen();
+    if( !pTopStream ) return false;
+    return pTopStream->isOpen();
 }
 
 Bu::size Bu::Client::write( const Bu::String &sData )
 {
-        return qbWrite.write( sData.getStr(), sData.getSize() );
+    return qbWrite.write( sData.getStr(), sData.getSize() );
 }
 
 Bu::size Bu::Client::write( const void *pData, Bu::size nBytes )
 {
-        return qbWrite.write( pData, nBytes );
+    return qbWrite.write( pData, nBytes );
 }
 
 Bu::size Bu::Client::write( int8_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( int16_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( int32_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( int64_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( uint8_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( uint16_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( uint32_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::write( uint64_t nData )
 {
-        return qbWrite.write( (const char *)&nData, sizeof(nData) );
+    return qbWrite.write( (const char *)&nData, sizeof(nData) );
 }
 
 Bu::size Bu::Client::read( void *pData, Bu::size nBytes )
 {
-        return qbRead.read( pData, nBytes );
+    return qbRead.read( pData, nBytes );
 }
 
 Bu::size Bu::Client::peek( void *pData, int nBytes, int nOffset )
 {
-        return qbRead.peek( pData, nBytes, nOffset );
+    return qbRead.peek( pData, nBytes, nOffset );
 }
 
 Bu::size Bu::Client::getInputSize()
 {
-        return qbRead.getSize();
+    return qbRead.getSize();
 }
 
 Bu::size Bu::Client::getOutputSize()
 {
-        return qbWrite.getSize();
+    return qbWrite.getSize();
 }
 
 const Bu::TcpSocket *Bu::Client::getSocket() const
 {
-        return pSocket;
+    return pSocket;
 }
 
 void Bu::Client::disconnect()
 {
-        bWantsDisconnect = true;
+    bWantsDisconnect = true;
 }
 
 bool Bu::Client::wantsDisconnect()
 {
-        return bWantsDisconnect;
+    return bWantsDisconnect;
 }
 
 void Bu::Client::close()
 {
-        pTopStream->close();
+    pTopStream->close();
 }
 
 Bu::ClientLink *Bu::Client::getLink()
 {
-        return pfLink->createLink( this );
+    return pfLink->createLink( this );
 }
 
 void Bu::Client::onMessage( const Bu::String &sMsg )
 {
-        if( pProto )
-                pProto->onMessage( this, sMsg );
+    if( pProto )
+        pProto->onMessage( this, sMsg );
 }
 
 void Bu::Client::tick()
 {
-        if( pProto )
-                pProto->onTick( this );
+    if( pProto )
+        pProto->onTick( this );
 }
 
 Bu::size Bu::Client::tell()
 {
-        return 0;
+    return 0;
 }
 
 void Bu::Client::seek( Bu::size offset )
 {
-        return qbRead.seek( offset );
+    return qbRead.seek( offset );
 }
 
 void Bu::Client::setPos( Bu::size )
 {
-        throw Bu::ExceptionBase();
+    throw Bu::ExceptionBase();
 }
 
 void Bu::Client::setPosEnd( Bu::size )
 {
-        throw Bu::ExceptionBase();
+    throw Bu::ExceptionBase();
 }
 
 bool Bu::Client::isEos()
 {
-        return true;
+    return true;
 }
 
 void Bu::Client::flush()
 {
-        processOutput();
+    processOutput();
 }
 
 bool Bu::Client::canRead()
 {
-        return qbRead.getSize() > 0;
+    return qbRead.getSize() > 0;
 }
 
 bool Bu::Client::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Client::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Client::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Client::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::Client::isBlocking()
 {
-        return false;
+    return false;
 }
 
 void Bu::Client::setBlocking( bool )
 {
-        throw Bu::ExceptionBase();
+    throw Bu::ExceptionBase();
 }
 
 void Bu::Client::setSize( Bu::size )
 {
-        throw Bu::ExceptionBase();
+    throw Bu::ExceptionBase();
 }
 
 Bu::size Bu::Client::getSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::Client::getBlockSize() const
 {
-        return pSocket->getBlockSize();
+    return pSocket->getBlockSize();
 }
 
 Bu::String Bu::Client::getLocation() const
 {
-        return pSocket->getLocation();
+    return pSocket->getLocation();
 }
 
diff --git a/src/stable/client.h b/src/stable/client.h
index 6bd41af..cacc8aa 100644
--- a/src/stable/client.h
+++ b/src/stable/client.h
@@ -16,118 +16,118 @@
 
 namespace Bu
 {
-        class Protocol;
-        class Stream;
-        class TcpSocket;
-        class ClientLinkFactory;
-
-        /**
-         *@ingroup Serving
-         */
-        class Client : public Bu::Stream
-        {
-        public:
-                Client( Bu::TcpSocket *pSocket, Bu::ClientLinkFactory *pfLink );
-                virtual ~Client();
-
-                void processInput();
-                void processOutput();
-
-                //Bu::String &getInput();
-                //Bu::String &getOutput();
-                Bu::size write( const Bu::String &sData );
-                Bu::size write( const void *pData, Bu::size nBytes );
-                Bu::size write( int8_t nData );
-                Bu::size write( int16_t nData );
-                Bu::size write( int32_t nData );
-                Bu::size write( int64_t nData );
-                Bu::size write( uint8_t nData );
-                Bu::size write( uint16_t nData );
-                Bu::size write( uint32_t nData );
-                Bu::size write( uint64_t nData );
-                Bu::size read( void *pData, Bu::size nBytes );
-                Bu::size peek( void *pData, int nBytes, int nOffset=0 );
-//              void seek( int nBytes );
-                Bu::size getInputSize();
-                Bu::size getOutputSize();
-
-                void setProtocol( Protocol *pProto );
-                Bu::Protocol *getProtocol();
-                void clearProtocol();
-
-                bool isOpen();
-                void close();
-                void tick();
-
-                const Bu::TcpSocket *getSocket() const;
-
-                void disconnect();
-                bool wantsDisconnect();
-
-                class ClientLink *getLink();
-
-                void onMessage( const Bu::String &sMsg );
-
-                bool hasOutput() { return qbWrite.getSize() > 0; }
-                bool hasInput() { return qbRead.getSize() > 0; }
-
-                template<typename filter>
-                void pushFilter()
-                {
-                        filter *pFlt = new filter( *pTopStream );
-                        pTopStream = pFlt;
-                        lFilts.prepend( pFlt );
-                }
-                
-                template<typename filter, typename p1t>
-                void pushFilter( p1t p1 )
-                {
-                        filter *pFlt = new filter( *pTopStream, p1 );
-                        pTopStream = pFlt;
-                        lFilts.prepend( pFlt );
-                }
-                
-                template<typename filter, typename p1t, typename p2t>
-                void pushFilter( p1t p1, p2t p2 )
-                {
-                        filter *pFlt = new filter( *pTopStream, p1, p2 );
-                        pTopStream = pFlt;
-                        lFilts.prepend( pFlt );
-                }
-
-                /*
-                 * These are required to qualify as a stream, I dunno how many will
-                 * be implemented.
-                 */
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-
-        private:
-                typedef Bu::List<Bu::Stream *> FilterList;
-                FilterList lFilts;
-                Bu::Stream *pTopStream;
-                Bu::TcpSocket *pSocket;
-                Bu::Protocol *pProto;
-                Bu::QueueBuf qbRead;
-                Bu::QueueBuf qbWrite;
-                bool bWantsDisconnect;
-                class Bu::ClientLinkFactory *pfLink;
-        };
+    class Protocol;
+    class Stream;
+    class TcpSocket;
+    class ClientLinkFactory;
+
+    /**
+     *@ingroup Serving
+     */
+    class Client : public Bu::Stream
+    {
+    public:
+        Client( Bu::TcpSocket *pSocket, Bu::ClientLinkFactory *pfLink );
+        virtual ~Client();
+
+        void processInput();
+        void processOutput();
+
+        //Bu::String &getInput();
+        //Bu::String &getOutput();
+        Bu::size write( const Bu::String &sData );
+        Bu::size write( const void *pData, Bu::size nBytes );
+        Bu::size write( int8_t nData );
+        Bu::size write( int16_t nData );
+        Bu::size write( int32_t nData );
+        Bu::size write( int64_t nData );
+        Bu::size write( uint8_t nData );
+        Bu::size write( uint16_t nData );
+        Bu::size write( uint32_t nData );
+        Bu::size write( uint64_t nData );
+        Bu::size read( void *pData, Bu::size nBytes );
+        Bu::size peek( void *pData, int nBytes, int nOffset=0 );
+//      void seek( int nBytes );
+        Bu::size getInputSize();
+        Bu::size getOutputSize();
+
+        void setProtocol( Protocol *pProto );
+        Bu::Protocol *getProtocol();
+        void clearProtocol();
+
+        bool isOpen();
+        void close();
+        void tick();
+
+        const Bu::TcpSocket *getSocket() const;
+
+        void disconnect();
+        bool wantsDisconnect();
+
+        class ClientLink *getLink();
+
+        void onMessage( const Bu::String &sMsg );
+
+        bool hasOutput() { return qbWrite.getSize() > 0; }
+        bool hasInput() { return qbRead.getSize() > 0; }
+
+        template<typename filter>
+        void pushFilter()
+        {
+            filter *pFlt = new filter( *pTopStream );
+            pTopStream = pFlt;
+            lFilts.prepend( pFlt );
+        }
+        
+        template<typename filter, typename p1t>
+        void pushFilter( p1t p1 )
+        {
+            filter *pFlt = new filter( *pTopStream, p1 );
+            pTopStream = pFlt;
+            lFilts.prepend( pFlt );
+        }
+        
+        template<typename filter, typename p1t, typename p2t>
+        void pushFilter( p1t p1, p2t p2 )
+        {
+            filter *pFlt = new filter( *pTopStream, p1, p2 );
+            pTopStream = pFlt;
+            lFilts.prepend( pFlt );
+        }
+
+        /*
+         * These are required to qualify as a stream, I dunno how many will
+         * be implemented.
+         */
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+
+    private:
+        typedef Bu::List<Bu::Stream *> FilterList;
+        FilterList lFilts;
+        Bu::Stream *pTopStream;
+        Bu::TcpSocket *pSocket;
+        Bu::Protocol *pProto;
+        Bu::QueueBuf qbRead;
+        Bu::QueueBuf qbWrite;
+        bool bWantsDisconnect;
+        class Bu::ClientLinkFactory *pfLink;
+    };
 }
 
 #endif
diff --git a/src/stable/clientlink.h b/src/stable/clientlink.h
index b5cd74d..d822c93 100644
--- a/src/stable/clientlink.h
+++ b/src/stable/clientlink.h
@@ -12,14 +12,14 @@
 
 namespace Bu
 {
-        class ClientLink
-        {
-        public:
-                ClientLink();
-                virtual ~ClientLink();
+    class ClientLink
+    {
+    public:
+        ClientLink();
+        virtual ~ClientLink();
 
-                virtual void sendMessage( const Bu::String &sMsg )=0;
-        };
+        virtual void sendMessage( const Bu::String &sMsg )=0;
+    };
 };
 
 #endif
diff --git a/src/stable/clientlinkfactory.h b/src/stable/clientlinkfactory.h
index b1b7670..bd64f6b 100644
--- a/src/stable/clientlinkfactory.h
+++ b/src/stable/clientlinkfactory.h
@@ -10,17 +10,17 @@
 
 namespace Bu
 {
-        class Client;
-        class ClientLink;
+    class Client;
+    class ClientLink;
 
-        class ClientLinkFactory
-        {
-        public:
-                ClientLinkFactory();
-                virtual ~ClientLinkFactory();
+    class ClientLinkFactory
+    {
+    public:
+        ClientLinkFactory();
+        virtual ~ClientLinkFactory();
 
-                virtual Bu::ClientLink *createLink( Bu::Client *pClient )=0;
-        };
+        virtual Bu::ClientLink *createLink( Bu::Client *pClient )=0;
+    };
 };
 
 #endif
diff --git a/src/stable/condition.cpp b/src/stable/condition.cpp
index 79af262..f02eca7 100644
--- a/src/stable/condition.cpp
+++ b/src/stable/condition.cpp
@@ -11,39 +11,39 @@
 
 Bu::Condition::Condition()
 {
-        pthread_cond_init( &cond, NULL );
+    pthread_cond_init( &cond, NULL );
 }
 
 Bu::Condition::~Condition()
 {
-        pthread_cond_destroy( &cond );
+    pthread_cond_destroy( &cond );
 }
 
 int Bu::Condition::wait()
 {
-        return pthread_cond_wait( &cond, &mutex );
+    return pthread_cond_wait( &cond, &mutex );
 }
 
 int Bu::Condition::wait( int nSec, int nUSec )
 {
-        struct timeval now;
-        struct timespec timeout;
-        struct timezone tz;
-        
-        gettimeofday( &now, &tz );
-        timeout.tv_sec = now.tv_sec + nSec + ((now.tv_usec + nUSec)/1000000);
-        timeout.tv_nsec = ((now.tv_usec + nUSec)%1000000)*1000;
-
-        return pthread_cond_timedwait( &cond, &mutex, &timeout );
+    struct timeval now;
+    struct timespec timeout;
+    struct timezone tz;
+    
+    gettimeofday( &now, &tz );
+    timeout.tv_sec = now.tv_sec + nSec + ((now.tv_usec + nUSec)/1000000);
+    timeout.tv_nsec = ((now.tv_usec + nUSec)%1000000)*1000;
+
+    return pthread_cond_timedwait( &cond, &mutex, &timeout );
 }
 
 int Bu::Condition::signal()
 {
-        return pthread_cond_signal( &cond );
+    return pthread_cond_signal( &cond );
 }
 
 int Bu::Condition::broadcast()
 {
-        return pthread_cond_broadcast( &cond );
+    return pthread_cond_broadcast( &cond );
 }
 
diff --git a/src/stable/condition.h b/src/stable/condition.h
index 2c27720..53eb9ff 100644
--- a/src/stable/condition.h
+++ b/src/stable/condition.h
@@ -14,77 +14,77 @@
 
 namespace Bu
 {
-        /**
-         * Ito condition.  This is a fairly simple condition mechanism.  As you may
-         * notice this class inherits from the Mutex class, this is because all
-         * conditions must be within a locked block.  The standard usage of a
-         * condition is to pause one thread, perhaps indefinately, until another
-         * thread signals that it is alright to procede.
-         * <br>
-         * Standard usage for the thread that wants to wait is as follows:
-         * <pre>
-         * Condition cond;
-         * ... // Perform setup and enter your run loop
-         * cond.lock();
-         * while( !isFinished() ) // Could be anything you're waiting for
-         *     cond.wait();
-         * ...  // Take care of what you have to.
-         * cond.unlock();
-         * </pre>
-         * The usage for the triggering thread is much simpler, when it needs to
-         * tell the others that it's time to grab some data it calls either signal
-         * or broadcast.  See both of those functions for the difference.
-         *@ingroup Threading
-         */
-        class Condition : public Mutex
-        {
-        public:
-                /**
-                 * Create a condition.
-                 */
-                Condition();
+    /**
+     * Ito condition.  This is a fairly simple condition mechanism.  As you may
+     * notice this class inherits from the Mutex class, this is because all
+     * conditions must be within a locked block.  The standard usage of a
+     * condition is to pause one thread, perhaps indefinately, until another
+     * thread signals that it is alright to procede.
+     * <br>
+     * Standard usage for the thread that wants to wait is as follows:
+     * <pre>
+     * Condition cond;
+     * ... // Perform setup and enter your run loop
+     * cond.lock();
+     * while( !isFinished() ) // Could be anything you're waiting for
+     *     cond.wait();
+     * ...  // Take care of what you have to.
+     * cond.unlock();
+     * </pre>
+     * The usage for the triggering thread is much simpler, when it needs to
+     * tell the others that it's time to grab some data it calls either signal
+     * or broadcast.  See both of those functions for the difference.
+     *@ingroup Threading
+     */
+    class Condition : public Mutex
+    {
+    public:
+        /**
+         * Create a condition.
+         */
+        Condition();
 
-                /**
-                 * Destroy a condition.
-                 */
-                ~Condition();
+        /**
+         * Destroy a condition.
+         */
+        ~Condition();
 
-                /**
-                 * Wait forever, or until signalled.  This has to be called from within
-                 * a locked section, i.e. before calling this this object's lock
-                 * function should be called.
-                 */
-                int wait();
+        /**
+         * Wait forever, or until signalled.  This has to be called from within
+         * a locked section, i.e. before calling this this object's lock
+         * function should be called.
+         */
+        int wait();
 
-                /**
-                 * Wait for a maximum of nSec seconds and nUSec micro-seconds or until
-                 * signalled.  This is a little more friendly function if you want to
-                 * perform other operations in the thrad loop that calls this function.
-                 * Like the other wait function, this must be inside a locked section.
-                 *@param nSec The seconds to wait.
-                 *@param nUSec the micro-seconds to wait.
-                 */
-                int wait( int nSec, int nUSec );
+        /**
+         * Wait for a maximum of nSec seconds and nUSec micro-seconds or until
+         * signalled.  This is a little more friendly function if you want to
+         * perform other operations in the thrad loop that calls this function.
+         * Like the other wait function, this must be inside a locked section.
+         *@param nSec The seconds to wait.
+         *@param nUSec the micro-seconds to wait.
+         */
+        int wait( int nSec, int nUSec );
 
-                /**
-                 * Notify the next thread waiting on this condition that they can go
-                 * ahead.  This only signals one thread, the next one in the condition
-                 * queue, that it is safe to procede with whatever operation was being
-                 * waited on.
-                 */
-                int signal();
+        /**
+         * Notify the next thread waiting on this condition that they can go
+         * ahead.  This only signals one thread, the next one in the condition
+         * queue, that it is safe to procede with whatever operation was being
+         * waited on.
+         */
+        int signal();
 
-                /**
-                 * Notify all threads waiting on this condition that they can go ahead
-                 * now. This function is slower than signal, but more effective in
-                 * certain situations where you may not know how many threads should be
-                 * activated.
-                 */
-                int broadcast();
+        /**
+         * Notify all threads waiting on this condition that they can go ahead
+         * now. This function is slower than signal, but more effective in
+         * certain situations where you may not know how many threads should be
+         * activated.
+         */
+        int broadcast();
 
-        private:
-                pthread_cond_t cond;    /**< Internal condition reference. */
-        };
+    private:
+        pthread_cond_t cond;    /**< Internal condition reference. */
+    };
 }
 
 #endif
diff --git a/src/stable/conduit.cpp b/src/stable/conduit.cpp
index 8f5eba5..4c2fda6 100644
--- a/src/stable/conduit.cpp
+++ b/src/stable/conduit.cpp
@@ -8,9 +8,9 @@
 #include "bu/conduit.h"
 
 Bu::Conduit::Conduit( int iBlockSize ) :
-        qb( iBlockSize ),
-        bBlocking( true ),
-        bOpen( true )
+    qb( iBlockSize ),
+    bBlocking( true ),
+    bOpen( true )
 {
 }
 
@@ -20,100 +20,100 @@ Bu::Conduit::~Conduit()
 
 void Bu::Conduit::close()
 {
-        im.lock();
-//      qb.close();
-        bOpen = false;
-        
-        cBlock.signal();
-        im.unlock();
+    im.lock();
+//  qb.close();
+    bOpen = false;
+    
+    cBlock.signal();
+    im.unlock();
 }
 
 #include <stdio.h>
 Bu::size Bu::Conduit::read( void *pBuf, Bu::size nBytes )
 {
-        if( !isOpen() )
-        {
-                return 0;
-        }
-        im.lock();
-        if( bBlocking )
-        {
-                im.unlock();
-                cBlock.lock();
-                for(;;)
-                {
-                        im.lock();
-                        if( qb.getSize() == 0 && bOpen == false )
-                        {
-                                im.unlock();
-                                cBlock.unlock();
-                                return 0;
-                        }
-                        else if( qb.getSize() > 0 )
-                        {
-                                im.unlock();
-                                break;
-                        }
-                        im.unlock();
-
-                        cBlock.wait();
-                }
-
-                im.lock();
-                Bu::size iRet = qb.read( pBuf, nBytes );
-                im.unlock();
-
-                cBlock.unlock();
-                return iRet;
-        }
-        else
-        {
-                Bu::size iRet = qb.read( pBuf, nBytes );
-                im.unlock();
-
-                return iRet;
-        }
+    if( !isOpen() )
+    {
+        return 0;
+    }
+    im.lock();
+    if( bBlocking )
+    {
+        im.unlock();
+        cBlock.lock();
+        for(;;)
+        {
+            im.lock();
+            if( qb.getSize() == 0 && bOpen == false )
+            {
+                im.unlock();
+                cBlock.unlock();
+                return 0;
+            }
+            else if( qb.getSize() > 0 )
+            {
+                im.unlock();
+                break;
+            }
+            im.unlock();
+
+            cBlock.wait();
+        }
+
+        im.lock();
+        Bu::size iRet = qb.read( pBuf, nBytes );
+        im.unlock();
+
+        cBlock.unlock();
+        return iRet;
+    }
+    else
+    {
+        Bu::size iRet = qb.read( pBuf, nBytes );
+        im.unlock();
+
+        return iRet;
+    }
 }
 
 Bu::size Bu::Conduit::peek( void *pBuf, Bu::size nBytes )
 {
-        im.lock();
-        Bu::size iRet = qb.peek( pBuf, nBytes );
-        im.unlock();
+    im.lock();
+    Bu::size iRet = qb.peek( pBuf, nBytes );
+    im.unlock();
 
-        return iRet;
+    return iRet;
 }
 
 Bu::size Bu::Conduit::peek( void *pBuf, Bu::size nBytes, Bu::size nSkip )
 {
-        im.lock();
-        Bu::size iRet = qb.peek( pBuf, nBytes, nSkip );
-        im.unlock();
+    im.lock();
+    Bu::size iRet = qb.peek( pBuf, nBytes, nSkip );
+    im.unlock();
 
-        return iRet;
+    return iRet;
 }
 
 Bu::size Bu::Conduit::write( const void *pBuf, Bu::size nBytes )
 {
-        im.lock();
-        if( bOpen == false )
-        {
-                im.unlock();
-                return 0;
-        }
-        Bu::size sRet = qb.write( pBuf, nBytes );
-        cBlock.signal();
-        im.unlock();
+    im.lock();
+    if( bOpen == false )
+    {
+        im.unlock();
+        return 0;
+    }
+    Bu::size sRet = qb.write( pBuf, nBytes );
+    cBlock.signal();
+    im.unlock();
 
-        return sRet;
+    return sRet;
 }
 
 Bu::size Bu::Conduit::tell()
 {
-        im.lock();
-        Bu::size sRet = qb.tell();
-        im.unlock();
-        return sRet;
+    im.lock();
+    Bu::size sRet = qb.tell();
+    im.unlock();
+    return sRet;
 }
 
 void Bu::Conduit::seek( Bu::size )
@@ -130,18 +130,18 @@ void Bu::Conduit::setPosEnd( Bu::size )
 
 bool Bu::Conduit::isEos()
 {
-        im.lock();
-        bool bRet = qb.isEos();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.isEos();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::isOpen()
 {
-        im.lock();
-        bool bRet = bOpen || (qb.getSize() > 0);
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = bOpen || (qb.getSize() > 0);
+    im.unlock();
+    return bRet;
 }
 
 void Bu::Conduit::flush()
@@ -150,57 +150,57 @@ void Bu::Conduit::flush()
 
 bool Bu::Conduit::canRead()
 {
-        im.lock();
-        bool bRet = qb.canRead();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.canRead();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::canWrite()
 {
-        im.lock();
-        bool bRet = qb.canWrite();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.canWrite();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::isReadable()
 {
-        im.lock();
-        bool bRet = qb.isReadable();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.isReadable();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::isWritable()
 {
-        im.lock();
-        bool bRet = qb.isWritable();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.isWritable();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::isSeekable()
 {
-        im.lock();
-        bool bRet = qb.isSeekable();
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = qb.isSeekable();
+    im.unlock();
+    return bRet;
 }
 
 bool Bu::Conduit::isBlocking()
 {
-        im.lock();
-        bool bRet = bBlocking;
-        im.unlock();
-        return bRet;
+    im.lock();
+    bool bRet = bBlocking;
+    im.unlock();
+    return bRet;
 }
 
 void Bu::Conduit::setBlocking( bool bBlocking )
 {
-        im.lock();
-        this->bBlocking = bBlocking;
-        im.unlock();
+    im.lock();
+    this->bBlocking = bBlocking;
+    im.unlock();
 }
 
 void Bu::Conduit::setSize( Bu::size )
@@ -209,25 +209,25 @@ void Bu::Conduit::setSize( Bu::size )
 
 Bu::size Bu::Conduit::getSize() const
 {
-        im.lock();
-        Bu::size sRet = qb.getSize();
-        im.unlock();
-        return sRet;
+    im.lock();
+    Bu::size sRet = qb.getSize();
+    im.unlock();
+    return sRet;
 }
 
 Bu::size Bu::Conduit::getBlockSize() const
 {
-        im.lock();
-        Bu::size sRet = qb.getBlockSize();
-        im.unlock();
-        return sRet;
+    im.lock();
+    Bu::size sRet = qb.getBlockSize();
+    im.unlock();
+    return sRet;
 }
 
 Bu::String Bu::Conduit::getLocation() const
 {
-        im.lock();
-        Bu::String sRet = qb.getLocation();
-        im.unlock();
-        return sRet;
+    im.lock();
+    Bu::String sRet = qb.getLocation();
+    im.unlock();
+    return sRet;
 }
 
diff --git a/src/stable/conduit.h b/src/stable/conduit.h
index a1959a9..78d24eb 100644
--- a/src/stable/conduit.h
+++ b/src/stable/conduit.h
@@ -16,49 +16,49 @@
 
 namespace Bu
 {
-        /**
-         * Simple inter-thread communication stream.  This acts like a pair of
-         * pipes for stream communication between any two things, but without the
-         * use of pipes, making this a bad choice for IPC.
-         */
-        class Conduit : public Stream
-        {
-        public:
-                Conduit( int iBlockSize=256 );
-                virtual ~Conduit();
+    /**
+     * Simple inter-thread communication stream.  This acts like a pair of
+     * pipes for stream communication between any two things, but without the
+     * use of pipes, making this a bad choice for IPC.
+     */
+    class Conduit : public Stream
+    {
+    public:
+        Conduit( int iBlockSize=256 );
+        virtual ~Conduit();
 
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size peek( void *pBuf, Bu::size nBytes );
-                virtual Bu::size peek( void *pBuf, Bu::size nBytes, Bu::size nSkip );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size peek( void *pBuf, Bu::size nBytes );
+        virtual Bu::size peek( void *pBuf, Bu::size nBytes, Bu::size nSkip );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
 
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-        private:
-                QueueBuf qb;
-                mutable Mutex im;
-                Condition cBlock;
-                bool bBlocking;
-                bool bOpen;
-        };
+    private:
+        QueueBuf qb;
+        mutable Mutex im;
+        Condition cBlock;
+        bool bBlocking;
+        bool bOpen;
+    };
 }
 
 #endif
diff --git a/src/stable/crypt.cpp b/src/stable/crypt.cpp
index 3f7fc83..2915cf4 100644
--- a/src/stable/crypt.cpp
+++ b/src/stable/crypt.cpp
@@ -13,35 +13,35 @@
 
 Bu::String Bu::cryptPass( const Bu::String &sPass, const Bu::String &sSalt )
 {
-        Bu::Md5 md5;
-        Bu::MemBuf mbOut;
-        Bu::Base64 b64Out( mbOut );
-        
-        Bu::String::const_iterator i = sSalt.find('$');
-        Bu::String sSaltSml = sSalt.getSubStr( sSalt.begin(), i );
+    Bu::Md5 md5;
+    Bu::MemBuf mbOut;
+    Bu::Base64 b64Out( mbOut );
+    
+    Bu::String::const_iterator i = sSalt.find('$');
+    Bu::String sSaltSml = sSalt.getSubStr( sSalt.begin(), i );
 
-        md5.addData( sPass );
-        md5.addData( sSaltSml );
-        md5.writeResult( b64Out );
+    md5.addData( sPass );
+    md5.addData( sSaltSml );
+    md5.writeResult( b64Out );
 
-        b64Out.stop();
+    b64Out.stop();
 
-        return sSaltSml + "$" + mbOut.getString();
+    return sSaltSml + "$" + mbOut.getString();
 }
 
 Bu::String Bu::cryptPass( const Bu::String &sPass )
 {
-        Bu::MemBuf mbSalt;
-        Bu::Base64 b64Salt( mbSalt );
-        Bu::File fRand("/dev/urandom", Bu::File::Read );
+    Bu::MemBuf mbSalt;
+    Bu::Base64 b64Salt( mbSalt );
+    Bu::File fRand("/dev/urandom", Bu::File::Read );
 
 #define STR 6
-        char buf[STR];
-        fRand.read( buf, STR );
-        b64Salt.write( buf, STR );
+    char buf[STR];
+    fRand.read( buf, STR );
+    b64Salt.write( buf, STR );
 
-        b64Salt.stop();
+    b64Salt.stop();
 
-        return cryptPass( sPass, mbSalt.getString() );
+    return cryptPass( sPass, mbSalt.getString() );
 }
 
diff --git a/src/stable/crypt.h b/src/stable/crypt.h
index 14adc3a..5093610 100644
--- a/src/stable/crypt.h
+++ b/src/stable/crypt.h
@@ -12,8 +12,8 @@
 
 namespace Bu
 {
-        String cryptPass( const Bu::String &sPass, const Bu::String &sSalt );
-        String cryptPass( const Bu::String &sPass );
+    String cryptPass( const Bu::String &sPass, const Bu::String &sSalt );
+    String cryptPass( const Bu::String &sPass );
 };
 
 #endif
diff --git a/src/stable/cryptohash.cpp b/src/stable/cryptohash.cpp
index dda734c..99a7d92 100644
--- a/src/stable/cryptohash.cpp
+++ b/src/stable/cryptohash.cpp
@@ -17,22 +17,22 @@ Bu::CryptoHash::~CryptoHash()
 
 void Bu::CryptoHash::addData( const Bu::String &sData )
 {
-        addData( sData.getStr(), sData.getSize() );
+    addData( sData.getStr(), sData.getSize() );
 }
 
 Bu::String Bu::CryptoHash::getHexResult()
 {
-        Bu::String sResult = getResult();
-        Bu::String sRet( 2*sResult.getSize() );
-        static const char hex_tab[] = {"0123456789abcdef"};
-
-        int k = 0;
-        for( int i = 0; i < sResult.getSize(); i++ )
-        {
-                sRet[k++] = hex_tab[(((unsigned char)sResult[i])>>4) & 0xF];
-                sRet[k++] = hex_tab[((unsigned char)sResult[i]) & 0xF];
-        }
-
-        return sRet;    
+    Bu::String sResult = getResult();
+    Bu::String sRet( 2*sResult.getSize() );
+    static const char hex_tab[] = {"0123456789abcdef"};
+
+    int k = 0;
+    for( int i = 0; i < sResult.getSize(); i++ )
+    {
+        sRet[k++] = hex_tab[(((unsigned char)sResult[i])>>4) & 0xF];
+        sRet[k++] = hex_tab[((unsigned char)sResult[i]) & 0xF];
+    }
+
+    return sRet;    
 }
 
diff --git a/src/stable/cryptohash.h b/src/stable/cryptohash.h
index 3f13b05..a943590 100644
--- a/src/stable/cryptohash.h
+++ b/src/stable/cryptohash.h
@@ -12,22 +12,22 @@
 
 namespace Bu
 {
-        class Stream;
+    class Stream;
 
-        class CryptoHash
-        {
-        public:
-                CryptoHash();
-                virtual ~CryptoHash();
+    class CryptoHash
+    {
+    public:
+        CryptoHash();
+        virtual ~CryptoHash();
 
-                virtual void reset() = 0;
-                virtual void setSalt( const Bu::String &sSalt ) = 0;
-                virtual void addData( const void *sData, int iSize ) = 0;
-                virtual void addData( const Bu::String &sData );
-                virtual String getResult() = 0;
-                virtual void writeResult( Stream &sOut ) = 0;
-                virtual Bu::String getHexResult();
-        };
+        virtual void reset() = 0;
+        virtual void setSalt( const Bu::String &sSalt ) = 0;
+        virtual void addData( const void *sData, int iSize ) = 0;
+        virtual void addData( const Bu::String &sData );
+        virtual String getResult() = 0;
+        virtual void writeResult( Stream &sOut ) = 0;
+        virtual Bu::String getHexResult();
+    };
 };
 
 #endif
diff --git a/src/stable/csvreader.cpp b/src/stable/csvreader.cpp
index ddc68f0..c27c8ee 100644
--- a/src/stable/csvreader.cpp
+++ b/src/stable/csvreader.cpp
@@ -12,24 +12,24 @@
 using namespace Bu;
 
 Bu::CsvReader::CsvReader( Bu::Stream &sIn, Bu::CsvReader::Style eStyle ) :
-        sIn( sIn )
+    sIn( sIn )
 {
-        switch( eStyle )
-        {
-                case styleExcel:
-                        sDecode = Bu::slot( &decodeExcel );
-                        break;
-
-                case styleC:
-                        sDecode = Bu::slot( &decodeC );
-                        break;
-        }
+    switch( eStyle )
+    {
+        case styleExcel:
+            sDecode = Bu::slot( &decodeExcel );
+            break;
+
+        case styleC:
+            sDecode = Bu::slot( &decodeC );
+            break;
+    }
 }
 
 Bu::CsvReader::CsvReader( Bu::Stream &sIn,
-                Bu::CsvReader::DecodeSignal sDecode ) :
-        sIn( sIn ),
-        sDecode( sDecode )
+        Bu::CsvReader::DecodeSignal sDecode ) :
+    sIn( sIn ),
+    sDecode( sDecode )
 {
 }
 
@@ -39,61 +39,61 @@ Bu::CsvReader::~CsvReader()
 
 Bu::StrArray Bu::CsvReader::readLine()
 {
-        Bu::StrArray aVals;
-
-        Bu::String sLine = sIn.readLine();
-
-        if( !sLine.isSet() )
-                return Bu::StrArray();
-
-        Bu::String::iterator i = sLine.begin();
-
-        aVals.append( sDecode( i ) );
-
-        while( i )
-        {
-                if( *i == ',' )
-                {
-                        i++;
-                        if( !i )
-                        {
-                                aVals.append("");
-                                break;
-                        }
-                        aVals.append( sDecode( i ) );
-                }
-                else
-                {
-                        // Blanks and stuff?
-                        sio << "Out of bound:  '" << *i << "'" << sio.nl;
-                        i++;
-                }
-        }
-
-        return aVals;
+    Bu::StrArray aVals;
+
+    Bu::String sLine = sIn.readLine();
+
+    if( !sLine.isSet() )
+        return Bu::StrArray();
+
+    Bu::String::iterator i = sLine.begin();
+
+    aVals.append( sDecode( i ) );
+
+    while( i )
+    {
+        if( *i == ',' )
+        {
+            i++;
+            if( !i )
+            {
+                aVals.append("");
+                break;
+            }
+            aVals.append( sDecode( i ) );
+        }
+        else
+        {
+            // Blanks and stuff?
+            sio << "Out of bound:  '" << *i << "'" << sio.nl;
+            i++;
+        }
+    }
+
+    return aVals;
 }
 
 Bu::String Bu::CsvReader::decodeExcel( Bu::String::iterator &i )
 {
-        Bu::String sRet;
+    Bu::String sRet;
 
-        for(; i && (*i == ' ' || *i == '\t'); i++ ) { }
-        
-        if( !i )
-                return sRet;
+    for(; i && (*i == ' ' || *i == '\t'); i++ ) { }
+    
+    if( !i )
+        return sRet;
 
-        if( *i == '\"' )
+    if( *i == '\"' )
         {
                 for( i++ ; i; i++ )
                 {
                         if( *i == '\"' )
-                        {
-                                i++;
-                                if( !i )
-                                {
-                                        return sRet;
-                                }
-                                else if( *i == '\"' )
+            {
+                i++;
+                if( !i )
+                {
+                    return sRet;
+                }
+                else if( *i == '\"' )
                                 {
                                         sRet += *i;
                                 }
diff --git a/src/stable/csvreader.h b/src/stable/csvreader.h
index 6825da3..cb2a560 100644
--- a/src/stable/csvreader.h
+++ b/src/stable/csvreader.h
@@ -14,32 +14,32 @@
 
 namespace Bu
 {
-        class Stream;
-        typedef Bu::Array<Bu::String> StrArray;
-
-        class CsvReader
-        {
-        public:
-                typedef Bu::Signal1<Bu::String, Bu::String::iterator &> DecodeSignal;
-                enum Style
-                {
-                        styleExcel, ///< Excel style quotes around things that need em
-                        styleC          ///< Escape things that need it C-style
-                };
-
-                CsvReader( Stream &sIn, Style eStyle=styleExcel );
-                CsvReader( Stream &sIn, DecodeSignal sDecode );
-                virtual ~CsvReader();
-
-                StrArray readLine();
-
-        private:
-                Stream &sIn;
-                DecodeSignal sDecode;
-
-                static Bu::String decodeExcel( Bu::String::iterator &i );
-                static Bu::String decodeC( Bu::String::iterator &i );
-        };
+    class Stream;
+    typedef Bu::Array<Bu::String> StrArray;
+
+    class CsvReader
+    {
+    public:
+        typedef Bu::Signal1<Bu::String, Bu::String::iterator &> DecodeSignal;
+        enum Style
+        {
+            styleExcel, ///< Excel style quotes around things that need em
+            styleC      ///< Escape things that need it C-style
+        };
+
+        CsvReader( Stream &sIn, Style eStyle=styleExcel );
+        CsvReader( Stream &sIn, DecodeSignal sDecode );
+        virtual ~CsvReader();
+
+        StrArray readLine();
+
+    private:
+        Stream &sIn;
+        DecodeSignal sDecode;
+
+        static Bu::String decodeExcel( Bu::String::iterator &i );
+        static Bu::String decodeC( Bu::String::iterator &i );
+    };
 };
 
 #endif
diff --git a/src/stable/csvwriter.cpp b/src/stable/csvwriter.cpp
index a89b309..8b51115 100644
--- a/src/stable/csvwriter.cpp
+++ b/src/stable/csvwriter.cpp
@@ -9,24 +9,24 @@
 #include "bu/stream.h"
 
 Bu::CsvWriter::CsvWriter( Bu::Stream &sOut, Bu::CsvWriter::Style eStyle ) :
-        sOut( sOut )
+    sOut( sOut )
 {
-        switch( eStyle )
-        {
-                case styleExcel:
-                        sEncode = Bu::slot( &encodeExcel );
-                        break;
+    switch( eStyle )
+    {
+        case styleExcel:
+            sEncode = Bu::slot( &encodeExcel );
+            break;
 
-                case styleC:
-                        sEncode = Bu::slot( &encodeExcel );
-                        break;
-        }
+        case styleC:
+            sEncode = Bu::slot( &encodeExcel );
+            break;
+    }
 }
 
 Bu::CsvWriter::CsvWriter( Bu::Stream &sOut,
-                Bu::CsvWriter::EncodeSignal sEncode ) :
-        sOut( sOut ),
-        sEncode( sEncode )
+        Bu::CsvWriter::EncodeSignal sEncode ) :
+    sOut( sOut ),
+    sEncode( sEncode )
 {
 }
 
@@ -36,46 +36,46 @@ Bu::CsvWriter::~CsvWriter()
 
 void Bu::CsvWriter::writeLine( const StrArray &aStrs )
 {
-        Bu::String sBuf;
-        for( StrArray::const_iterator i = aStrs.begin(); i; i++ )
-        {
-                if( i != aStrs.begin() )
-                        sBuf += ",";
-                sBuf += sEncode( *i );
-        }
-        sBuf += "\n";
+    Bu::String sBuf;
+    for( StrArray::const_iterator i = aStrs.begin(); i; i++ )
+    {
+        if( i != aStrs.begin() )
+            sBuf += ",";
+        sBuf += sEncode( *i );
+    }
+    sBuf += "\n";
 
-        sOut.write( sBuf );
+    sOut.write( sBuf );
 }
 
 Bu::String Bu::CsvWriter::encodeExcel( const Bu::String &sIn )
 {
-        if( sIn.find('\"') || sIn.find(',') )
+    if( sIn.find('\"') || sIn.find(',') )
         {
                 Bu::String sOut = "\"";
-                for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
-                {
-                        if( *i == '\"' )
+        for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
+        {
+            if( *i == '\"' )
                                 sOut += "\"\"";
                         else
                                 sOut += *i;
                 }
                 sOut += '\"';
-                return sOut;
-        }
-        return sIn;
+        return sOut;
+    }
+    return sIn;
 }
 
 Bu::String Bu::CsvWriter::encodeC( const Bu::String &sIn )
 {
-        Bu::String sOut = "";
-        for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
-        {
-                if( *i == ',' )
-                        sOut += "\\,";
-                else
-                        sOut += *i;
-        }
-        return sOut;
+    Bu::String sOut = "";
+    for( Bu::String::const_iterator i = sIn.begin(); i; i++ )
+    {
+        if( *i == ',' )
+            sOut += "\\,";
+        else
+            sOut += *i;
+    }
+    return sOut;
 }
 
diff --git a/src/stable/csvwriter.h b/src/stable/csvwriter.h
index bae1e1d..233f4ed 100644
--- a/src/stable/csvwriter.h
+++ b/src/stable/csvwriter.h
@@ -14,32 +14,32 @@
 
 namespace Bu
 {
-        class Stream;
-        typedef Bu::Array<Bu::String> StrArray;
-
-        class CsvWriter
-        {
-        public:
-                typedef Bu::Signal1<Bu::String, const Bu::String &> EncodeSignal;
-                enum Style
-                {
-                        styleExcel, ///< Excel style quotes around things that need em
-                        styleC          ///< Escape things that need it C-style
-                };
-
-                CsvWriter( Stream &sOut, Style eStyle=styleExcel );
-                CsvWriter( Stream &sOut, EncodeSignal sEncode );
-                virtual ~CsvWriter();
-
-                void writeLine( const StrArray &aStrs );
-
-        private:
-                Stream &sOut;
-                EncodeSignal sEncode;
-
-                static Bu::String encodeExcel( const Bu::String &sIn );
-                static Bu::String encodeC( const Bu::String &sIn );
-        };
+    class Stream;
+    typedef Bu::Array<Bu::String> StrArray;
+
+    class CsvWriter
+    {
+    public:
+        typedef Bu::Signal1<Bu::String, const Bu::String &> EncodeSignal;
+        enum Style
+        {
+            styleExcel, ///< Excel style quotes around things that need em
+            styleC      ///< Escape things that need it C-style
+        };
+
+        CsvWriter( Stream &sOut, Style eStyle=styleExcel );
+        CsvWriter( Stream &sOut, EncodeSignal sEncode );
+        virtual ~CsvWriter();
+
+        void writeLine( const StrArray &aStrs );
+
+    private:
+        Stream &sOut;
+        EncodeSignal sEncode;
+
+        static Bu::String encodeExcel( const Bu::String &sIn );
+        static Bu::String encodeC( const Bu::String &sIn );
+    };
 };
 
 #endif
diff --git a/src/stable/deflate.cpp b/src/stable/deflate.cpp
index b7e1804..57aa4aa 100644
--- a/src/stable/deflate.cpp
+++ b/src/stable/deflate.cpp
@@ -15,239 +15,239 @@
 using namespace Bu;
 
 Bu::Deflate::Deflate( Bu::Stream &rNext, int nCompression, Format eFmt ) :
-        Bu::Filter( rNext ),
-        prState( NULL ),
-        nCompression( nCompression ),
-        sTotalOut( 0 ),
-        eFmt( eFmt ),
-        bEos( false )
+    Bu::Filter( rNext ),
+    prState( NULL ),
+    nCompression( nCompression ),
+    sTotalOut( 0 ),
+    eFmt( eFmt ),
+    bEos( false )
 {
-        TRACE( nCompression );
-        start();
+    TRACE( nCompression );
+    start();
 }
 
 Bu::Deflate::~Deflate()
 {
-        TRACE();
-        stop();
+    TRACE();
+    stop();
 }
 
 void Bu::Deflate::start()
 {
-        TRACE();
-        prState = new z_stream;
-        pState->zalloc = NULL;
-        pState->zfree = NULL;
-        pState->opaque = NULL;
-        pState->state = NULL;
-
-        nBufSize = 64*1024;
-        pBuf = new char[nBufSize];
+    TRACE();
+    prState = new z_stream;
+    pState->zalloc = NULL;
+    pState->zfree = NULL;
+    pState->opaque = NULL;
+    pState->state = NULL;
+
+    nBufSize = 64*1024;
+    pBuf = new char[nBufSize];
 }
 
 Bu::size Bu::Deflate::stop()
 {
-        TRACE();
-        if( pState && pState->state )
-        {
-                if( bReading )
-                {
-                        inflateEnd( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return 0;
-                }
-                else
-                {
-                        for(;;)
-                        {
-                                pState->next_in = NULL;
-                                pState->avail_in = 0;
-                                pState->avail_out = nBufSize;
-                                pState->next_out = (Bytef *)pBuf;
-                                int res = deflate( pState, Z_FINISH );
-                                if( pState->avail_out < nBufSize )
-                                {
-                                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                                }
-                                if( res == Z_STREAM_END )
-                                        break;
-                        }
-                        deflateEnd( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return sTotalOut;
-                }
-        }
-        return 0;
+    TRACE();
+    if( pState && pState->state )
+    {
+        if( bReading )
+        {
+            inflateEnd( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return 0;
+        }
+        else
+        {
+            for(;;)
+            {
+                pState->next_in = NULL;
+                pState->avail_in = 0;
+                pState->avail_out = nBufSize;
+                pState->next_out = (Bytef *)pBuf;
+                int res = deflate( pState, Z_FINISH );
+                if( pState->avail_out < nBufSize )
+                {
+                    sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                }
+                if( res == Z_STREAM_END )
+                    break;
+            }
+            deflateEnd( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return sTotalOut;
+        }
+    }
+    return 0;
 }
 
 void Bu::Deflate::zError( int code )
 {
-        TRACE( code );
-        switch( code )
-        {
-                case Z_OK:
-                case Z_STREAM_END:
-                case Z_NEED_DICT:
-                        return;
+    TRACE( code );
+    switch( code )
+    {
+        case Z_OK:
+        case Z_STREAM_END:
+        case Z_NEED_DICT:
+            return;
 
-                case Z_ERRNO:
-                        throw ExceptionBase("Deflate: Errno - %s", pState->msg );
+        case Z_ERRNO:
+            throw ExceptionBase("Deflate: Errno - %s", pState->msg );
 
-                case Z_STREAM_ERROR:
-                        throw ExceptionBase("Deflate: Stream Error - %s", pState->msg );
+        case Z_STREAM_ERROR:
+            throw ExceptionBase("Deflate: Stream Error - %s", pState->msg );
 
-                case Z_DATA_ERROR:
-                        throw ExceptionBase("Deflate: Data Error - %s", pState->msg );
+        case Z_DATA_ERROR:
+            throw ExceptionBase("Deflate: Data Error - %s", pState->msg );
 
-                case Z_MEM_ERROR:
-                        throw ExceptionBase("Deflate: Mem Error - %s", pState->msg );
+        case Z_MEM_ERROR:
+            throw ExceptionBase("Deflate: Mem Error - %s", pState->msg );
 
-                case Z_BUF_ERROR:
-                        throw ExceptionBase("Deflate: Buf Error - %s", pState->msg );
+        case Z_BUF_ERROR:
+            throw ExceptionBase("Deflate: Buf Error - %s", pState->msg );
 
-                case Z_VERSION_ERROR:
-                        throw ExceptionBase("Deflate: Version Error - %s", pState->msg );
+        case Z_VERSION_ERROR:
+            throw ExceptionBase("Deflate: Version Error - %s", pState->msg );
 
-                default:
-                        throw ExceptionBase("Deflate: Unknown error encountered - %s.", pState->msg );
-        
-        }
+        default:
+            throw ExceptionBase("Deflate: Unknown error encountered - %s.", pState->msg );
+    
+    }
 }
 
 Bu::size Bu::Deflate::read( void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( nBytes  <= 0 )
-                return 0;
-        if( !pState->state )
-        {
-                bReading = true;
-                if( eFmt&AutoDetect )
-                        inflateInit2( pState, 32+15 ); // Auto-detect, large window
-                else if( eFmt == Raw )
-                        inflateInit2( pState, -15 ); // Raw
-                else if( eFmt == Zlib )
-                        inflateInit2( pState, 15 ); // Zlib
-                else if( eFmt == Gzip )
-                        inflateInit2( pState, 16+15 ); // GZip
-                else
-                        throw Bu::ExceptionBase("Format mode for deflate read.");
-                pState->next_in = (Bytef *)pBuf;
-                pState->avail_in = 0;
-        }
-        if( bReading == false )
-                throw ExceptionBase("This deflate filter is in writing mode, you can't read.");
-
-        int nRead = 0;
-        int nReadTotal = pState->total_out;
-        pState->next_out = (Bytef *)pData;
-        pState->avail_out = nBytes;
-        for(;;)
-        {
-                int ret = inflate( pState, Z_NO_FLUSH );
-                nReadTotal += nRead-pState->avail_out;
-
-                if( ret == Z_STREAM_END )
-                {
-                        bEos = true;
-                        if( pState->avail_in > 0 )
-                        {
-                                if( rNext.isSeekable() )
-                                {
-                                        rNext.seek( -pState->avail_in );
-                                }
-                        }
-                        return nBytes-pState->avail_out;
-                }
-                if( ret != Z_BUF_ERROR )
-                        zError( ret );
-
-                if( pState->avail_out )
-                {
-                        if( pState->avail_in == 0 )
-                        {
-                                nRead = rNext.read( pBuf, nBufSize );
-                                if( nRead == 0 && rNext.isEos() )
-                                {
-                                        throw Bu::ExceptionBase("Premature end of underlying "
-                                                        "stream found reading deflate stream.");
-                                }
-                                pState->next_in = (Bytef *)pBuf;
-                                pState->avail_in = nRead;
-                        }
-                }
-                else
-                {
-                        return nBytes-pState->avail_out;
-                }
-        }
-        return 0;
+    TRACE( pData, nBytes );
+    if( nBytes  <= 0 )
+        return 0;
+    if( !pState->state )
+    {
+        bReading = true;
+        if( eFmt&AutoDetect )
+            inflateInit2( pState, 32+15 ); // Auto-detect, large window
+        else if( eFmt == Raw )
+            inflateInit2( pState, -15 ); // Raw
+        else if( eFmt == Zlib )
+            inflateInit2( pState, 15 ); // Zlib
+        else if( eFmt == Gzip )
+            inflateInit2( pState, 16+15 ); // GZip
+        else
+            throw Bu::ExceptionBase("Format mode for deflate read.");
+        pState->next_in = (Bytef *)pBuf;
+        pState->avail_in = 0;
+    }
+    if( bReading == false )
+        throw ExceptionBase("This deflate filter is in writing mode, you can't read.");
+
+    int nRead = 0;
+    int nReadTotal = pState->total_out;
+    pState->next_out = (Bytef *)pData;
+    pState->avail_out = nBytes;
+    for(;;)
+    {
+        int ret = inflate( pState, Z_NO_FLUSH );
+        nReadTotal += nRead-pState->avail_out;
+
+        if( ret == Z_STREAM_END )
+        {
+            bEos = true;
+            if( pState->avail_in > 0 )
+            {
+                if( rNext.isSeekable() )
+                {
+                    rNext.seek( -pState->avail_in );
+                }
+            }
+            return nBytes-pState->avail_out;
+        }
+        if( ret != Z_BUF_ERROR )
+            zError( ret );
+
+        if( pState->avail_out )
+        {
+            if( pState->avail_in == 0 )
+            {
+                nRead = rNext.read( pBuf, nBufSize );
+                if( nRead == 0 && rNext.isEos() )
+                {
+                    throw Bu::ExceptionBase("Premature end of underlying "
+                            "stream found reading deflate stream.");
+                }
+                pState->next_in = (Bytef *)pBuf;
+                pState->avail_in = nRead;
+            }
+        }
+        else
+        {
+            return nBytes-pState->avail_out;
+        }
+    }
+    return 0;
 }
 
 Bu::size Bu::Deflate::write( const void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( nBytes  <= 0 )
-                return 0;
-        if( !pState->state )
-        {
-                bReading = false;
-                int iFmt = eFmt&Gzip;
-                if( iFmt == Raw )
-                        deflateInit2( pState, nCompression, Z_DEFLATED, -15, 9,
-                                Z_DEFAULT_STRATEGY );
-                else if( iFmt == Zlib )
-                        deflateInit2( pState, nCompression, Z_DEFLATED, 15, 9,
-                                Z_DEFAULT_STRATEGY );
-                else if( iFmt == Gzip )
-                        deflateInit2( pState, nCompression, Z_DEFLATED, 16+15, 9,
-                                Z_DEFAULT_STRATEGY );
-                else
-                        throw Bu::ExceptionBase("Invalid format for deflate.");
-        }
-        if( bReading == true )
-                throw ExceptionBase("This deflate filter is in reading mode, you can't write.");
-
-        pState->next_in = (Bytef *)pData;
-        pState->avail_in = nBytes;
-        for(;;)
-        {
-                pState->avail_out = nBufSize;
-                pState->next_out = (Bytef *)pBuf;
-
-                zError( deflate( pState, Z_NO_FLUSH ) );
-
-                if( pState->avail_out < nBufSize )
-                {
-                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                }
-                if( pState->avail_in == 0 )
-                        break;
-        }
-
-        return nBytes;
+    TRACE( pData, nBytes );
+    if( nBytes  <= 0 )
+        return 0;
+    if( !pState->state )
+    {
+        bReading = false;
+        int iFmt = eFmt&Gzip;
+        if( iFmt == Raw )
+            deflateInit2( pState, nCompression, Z_DEFLATED, -15, 9,
+                Z_DEFAULT_STRATEGY );
+        else if( iFmt == Zlib )
+            deflateInit2( pState, nCompression, Z_DEFLATED, 15, 9,
+                Z_DEFAULT_STRATEGY );
+        else if( iFmt == Gzip )
+            deflateInit2( pState, nCompression, Z_DEFLATED, 16+15, 9,
+                Z_DEFAULT_STRATEGY );
+        else
+            throw Bu::ExceptionBase("Invalid format for deflate.");
+    }
+    if( bReading == true )
+        throw ExceptionBase("This deflate filter is in reading mode, you can't write.");
+
+    pState->next_in = (Bytef *)pData;
+    pState->avail_in = nBytes;
+    for(;;)
+    {
+        pState->avail_out = nBufSize;
+        pState->next_out = (Bytef *)pBuf;
+
+        zError( deflate( pState, Z_NO_FLUSH ) );
+
+        if( pState->avail_out < nBufSize )
+        {
+            sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+        }
+        if( pState->avail_in == 0 )
+            break;
+    }
+
+    return nBytes;
 }
 
 bool Bu::Deflate::isOpen()
 {
-        TRACE();
-        return (pState != NULL && pState->state != NULL);
+    TRACE();
+    return (pState != NULL && pState->state != NULL);
 }
 
 bool Bu::Deflate::isEos()
 {
-        TRACE();
-        return bEos;
+    TRACE();
+    return bEos;
 }
 
 Bu::size Bu::Deflate::getCompressedSize()
 {
-        return sTotalOut;
+    return sTotalOut;
 }
 
diff --git a/src/stable/deflate.h b/src/stable/deflate.h
index 114b173..2ccd53f 100644
--- a/src/stable/deflate.h
+++ b/src/stable/deflate.h
@@ -14,53 +14,53 @@
 
 namespace Bu
 {
-        /**
-         * Provides Deflate (LZ77) support via zlib.  This provides zlib, raw, and
-         * gzip stream types.  By default it will autodetect the input type and
-         * encode into a raw deflate stream.
-         *
-         *@ingroup Streams
-         *@ingroup Compression
-         */
-        class Deflate : public Bu::Filter
-        {
-        public:
-                enum Format
-                {
-                        Raw                     = 0x01,
-                        Zlib            = 0x02,
-                        Gzip            = 0x03,
-                        AutoDetect      = 0x04,
+    /**
+     * Provides Deflate (LZ77) support via zlib.  This provides zlib, raw, and
+     * gzip stream types.  By default it will autodetect the input type and
+     * encode into a raw deflate stream.
+     *
+     *@ingroup Streams
+     *@ingroup Compression
+     */
+    class Deflate : public Bu::Filter
+    {
+    public:
+        enum Format
+        {
+            Raw         = 0x01,
+            Zlib        = 0x02,
+            Gzip        = 0x03,
+            AutoDetect  = 0x04,
 
-                        AutoRaw         = 0x04|0x01,
-                        AutoZlib        = 0x04|0x02,
-                        AutoGzip        = 0x04|0x03
-                };
+            AutoRaw     = 0x04|0x01,
+            AutoZlib    = 0x04|0x02,
+            AutoGzip    = 0x04|0x03
+        };
 
-                Deflate( Bu::Stream &rNext, int nCompression=-1, Format eFmt=AutoZlib );
-                virtual ~Deflate();
+        Deflate( Bu::Stream &rNext, int nCompression=-1, Format eFmt=AutoZlib );
+        virtual ~Deflate();
 
-                virtual void start();
-                virtual Bu::size stop();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        virtual void start();
+        virtual Bu::size stop();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
 
-                virtual bool isOpen();
-                virtual bool isEos();
+        virtual bool isOpen();
+        virtual bool isEos();
 
-                Bu::size getCompressedSize();
+        Bu::size getCompressedSize();
 
-        private:
-                void zError( int code );
-                void *prState;
-                bool bReading;
-                int nCompression;
-                char *pBuf;
-                uint32_t nBufSize;
-                Bu::size sTotalOut;
-                Format eFmt;
-                bool bEos;
-        };
+    private:
+        void zError( int code );
+        void *prState;
+        bool bReading;
+        int nCompression;
+        char *pBuf;
+        uint32_t nBufSize;
+        Bu::size sTotalOut;
+        Format eFmt;
+        bool bEos;
+    };
 }
 
 #endif
diff --git a/src/stable/exceptionbase.cpp b/src/stable/exceptionbase.cpp
index 87e7127..22f338f 100644
--- a/src/stable/exceptionbase.cpp
+++ b/src/stable/exceptionbase.cpp
@@ -11,83 +11,83 @@
 #include <stdio.h>
 
 Bu::ExceptionBase::ExceptionBase( const char *lpFormat, ... ) throw() :
-        nErrorCode( 0 ),
-        sWhat( NULL )
+    nErrorCode( 0 ),
+    sWhat( NULL )
 {
-        va_list ap;
+    va_list ap;
 
-        va_start(ap, lpFormat);
-        setWhat( lpFormat, ap );
-        va_end(ap);
+    va_start(ap, lpFormat);
+    setWhat( lpFormat, ap );
+    va_end(ap);
 }
 
 Bu::ExceptionBase::ExceptionBase( int nCode, const char *lpFormat, ... ) throw() :
-        nErrorCode( nCode ),
-        sWhat( NULL )
+    nErrorCode( nCode ),
+    sWhat( NULL )
 {
-        va_list ap;
+    va_list ap;
 
-        va_start(ap, lpFormat);
-        setWhat( lpFormat, ap );
-        va_end(ap);
+    va_start(ap, lpFormat);
+    setWhat( lpFormat, ap );
+    va_end(ap);
 }
 
 Bu::ExceptionBase::ExceptionBase( int nCode ) throw() :
-        nErrorCode( nCode ),
-        sWhat( NULL )
+    nErrorCode( nCode ),
+    sWhat( NULL )
 {
 }
 
 Bu::ExceptionBase::ExceptionBase( const ExceptionBase &e ) throw () :
-        std::exception( e ),
-        nErrorCode( e.nErrorCode ),
-        sWhat( NULL )
+    std::exception( e ),
+    nErrorCode( e.nErrorCode ),
+    sWhat( NULL )
 {
-        setWhat( e.sWhat );
+    setWhat( e.sWhat );
 }
 
 Bu::ExceptionBase::~ExceptionBase() throw()
 {
-        delete[] sWhat;
-        sWhat = NULL;
+    delete[] sWhat;
+    sWhat = NULL;
 }
 
 void Bu::ExceptionBase::setWhat( const char *lpFormat, va_list &vargs )
 {
-        if( sWhat ) delete[] sWhat;
-        int nSize;
-
-        va_list vargs2;
-        va_copy( vargs2, vargs );
-        nSize = vsnprintf( NULL, 0, lpFormat, vargs2 );
-        va_end( vargs2 );
-        sWhat = new char[nSize+1];
-        vsnprintf( sWhat, nSize+1, lpFormat, vargs );
+    if( sWhat ) delete[] sWhat;
+    int nSize;
+
+    va_list vargs2;
+    va_copy( vargs2, vargs );
+    nSize = vsnprintf( NULL, 0, lpFormat, vargs2 );
+    va_end( vargs2 );
+    sWhat = new char[nSize+1];
+    vsnprintf( sWhat, nSize+1, lpFormat, vargs );
 }
 
 void Bu::ExceptionBase::setWhat( const char *lpText )
 {
-        if( sWhat ) delete[] sWhat;
-        int nSize;
+    if( sWhat ) delete[] sWhat;
+    int nSize;
 
-        nSize = strlen( lpText );
-        sWhat = new char[nSize+1];
-        strcpy( sWhat, lpText );
+    nSize = strlen( lpText );
+    sWhat = new char[nSize+1];
+    strcpy( sWhat, lpText );
 }
 
 const char *Bu::ExceptionBase::what() const throw()
 {
-        return sWhat;
+    return sWhat;
 }
 
 int Bu::ExceptionBase::getErrorCode()
 {
-        return nErrorCode;
+    return nErrorCode;
 }
 
 Bu::UnsupportedException::UnsupportedException() throw() :
-        ExceptionBase( 0 )
+    ExceptionBase( 0 )
 {
-        setWhat("An unsupperted operation was attempted.");
+    setWhat("An unsupperted operation was attempted.");
 }
 
diff --git a/src/stable/exceptionbase.h b/src/stable/exceptionbase.h
index 9e6c72d..8f651b7 100644
--- a/src/stable/exceptionbase.h
+++ b/src/stable/exceptionbase.h
@@ -18,173 +18,173 @@
 
 namespace Bu
 {
-        /**
-         * A generalized Exception base class.  This is nice for making general and
-         * flexible child classes that can create new error code classes.
-         *
-         * In order to create your own exception class use these two lines.
-         * 
-         * in your header:  subExceptionDecl( NewClassName );
-         * 
-         * in your source:  subExcpetienDef( NewClassName );
-         */
-        class ExceptionBase : public std::exception
-        {
-        public:
-                /**
-                 * Construct an exception with an error code of zero, but with a
-                 * description.  The use of this is not reccomended most of the time,
-                 * it's generally best to include an error code with the exception so
-                 * your program can handle the exception in a better way.
-                 * @param sFormat The format of the text.  See printf for more info.
-                 */
-                ExceptionBase( const char *sFormat, ... ) throw();
-                
-                /**
-                 * 
-                 * @param nCode 
-                 * @param sFormat
-                 */
-                ExceptionBase( int nCode, const char *sFormat, ... ) throw();
-                
-                /**
-                 * 
-                 * @param nCode 
-                 * @return 
-                 */
-                ExceptionBase( int nCode=0 ) throw();
-
-                ExceptionBase( const ExceptionBase &e ) throw ();
-                
-                /**
-                 * 
-                 * @return 
-                 */
-                virtual ~ExceptionBase() throw();
-
-                /**
-                 * 
-                 * @return 
-                 */
-                virtual const char *what() const throw();
-                
-                /**
-                 * 
-                 * @return 
-                 */
-                int getErrorCode();
-                
-                /**
-                 * 
-                 * @param lpFormat 
-                 * @param vargs 
-                 */
-                void setWhat( const char *lpFormat, va_list &vargs );
-
-                /**
-                 *
-                 * @param lpText
-                 */
-                void setWhat( const char *lpText );
-
-        private:
-                int nErrorCode; /**< The code for the error that occured. */
-                char *sWhat;    /**< The text string telling people what went wrong. */
-        };
+    /**
+     * A generalized Exception base class.  This is nice for making general and
+     * flexible child classes that can create new error code classes.
+     *
+     * In order to create your own exception class use these two lines.
+     * 
+     * in your header:  subExceptionDecl( NewClassName );
+     * 
+     * in your source:  subExcpetienDef( NewClassName );
+     */
+    class ExceptionBase : public std::exception
+    {
+    public:
+        /**
+         * Construct an exception with an error code of zero, but with a
+         * description.  The use of this is not reccomended most of the time,
+         * it's generally best to include an error code with the exception so
+         * your program can handle the exception in a better way.
+         * @param sFormat The format of the text.  See printf for more info.
+         */
+        ExceptionBase( const char *sFormat, ... ) throw();
+        
+        /**
+         * 
+         * @param nCode 
+         * @param sFormat
+         */
+        ExceptionBase( int nCode, const char *sFormat, ... ) throw();
+        
+        /**
+         * 
+         * @param nCode 
+         * @return 
+         */
+        ExceptionBase( int nCode=0 ) throw();
+
+        ExceptionBase( const ExceptionBase &e ) throw ();
+        
+        /**
+         * 
+         * @return 
+         */
+        virtual ~ExceptionBase() throw();
+
+        /**
+         * 
+         * @return 
+         */
+        virtual const char *what() const throw();
+        
+        /**
+         * 
+         * @return 
+         */
+        int getErrorCode();
+        
+        /**
+         * 
+         * @param lpFormat 
+         * @param vargs 
+         */
+        void setWhat( const char *lpFormat, va_list &vargs );
+
+        /**
+         *
+         * @param lpText
+         */
+        void setWhat( const char *lpText );
+
+    private:
+        int nErrorCode; /**< The code for the error that occured. */
+        char *sWhat;    /**< The text string telling people what went wrong. */
+    };
 }
 
-#define subExceptionDecl( name )                                                                                        \
-class name : public Bu::ExceptionBase                                                                                   \
-{                                                                                                                                                       \
-        public:                                                                                                                                 \
-                name( const char *sFormat, ... ) throw ();                                                      \
-                name( int nCode, const char *sFormat, ... ) throw();                            \
-                name( int nCode=0 ) throw ();                                                                           \
-                name( const name &e ) throw ();                                                                         \
+#define subExceptionDecl( name )                                            \
+class name : public Bu::ExceptionBase                                           \
+{                                                                           \
+    public:                                                                 \
+        name( const char *sFormat, ... ) throw ();                          \
+        name( int nCode, const char *sFormat, ... ) throw();                \
+        name( int nCode=0 ) throw ();                                       \
+        name( const name &e ) throw ();                                     \
 };
 
-#define subExceptionDeclChild( name, parent )                                                           \
-class name : public parent                                                                                                      \
-{                                                                                                                                                       \
-        public:                                                                                                                                 \
-                name( const char *sFormat, ... ) throw ();                                                      \
-                name( int nCode, const char *sFormat, ... ) throw();                            \
-                name( int nCode=0 ) throw ();                                                                           \
-                name( const name &e ) throw ();                                                                         \
+#define subExceptionDeclChild( name, parent )                               \
+class name : public parent                                                  \
+{                                                                           \
+    public:                                                                 \
+        name( const char *sFormat, ... ) throw ();                          \
+        name( int nCode, const char *sFormat, ... ) throw();                \
+        name( int nCode=0 ) throw ();                                       \
+        name( const name &e ) throw ();                                     \
 };
 
-#define subExceptionDeclBegin( name )                                                                           \
-class name : public Bu::ExceptionBase                                                                           \
-{                                                                                                                                                       \
-        public:                                                                                                                                 \
-                name( const char *sFormat, ... ) throw ();                                                      \
-                name( int nCode, const char *sFormat, ... ) throw();                            \
-                name( int nCode=0 ) throw ();                                                                           \
-                name( const name &e ) throw ();
+#define subExceptionDeclBegin( name )                                       \
+class name : public Bu::ExceptionBase                                       \
+{                                                                           \
+    public:                                                                 \
+        name( const char *sFormat, ... ) throw ();                          \
+        name( int nCode, const char *sFormat, ... ) throw();                \
+        name( int nCode=0 ) throw ();                                       \
+        name( const name &e ) throw ();
 
-#define subExceptionDeclEnd()                                                                                           \
+#define subExceptionDeclEnd()                                               \
 };
 
-#define subExceptionDef( name )                                                                                         \
-name::name( const char *lpFormat, ... ) throw() :                                                       \
-        ExceptionBase( 0 )                                                                                                              \
-{                                                                                                                                                       \
-        va_list ap;                                                                                                                             \
-        va_start( ap, lpFormat );                                                                                               \
-        setWhat( lpFormat, ap );                                                                                                \
-        va_end( ap );                                                                                                                   \
-}                                                                                                                                                       \
-name::name( int nCode, const char *lpFormat, ... ) throw() :                            \
-        ExceptionBase( nCode )                                                                                                  \
-{                                                                                                                                                       \
-        va_list ap;                                                                                                                             \
-        va_start( ap, lpFormat );                                                                                               \
-        setWhat( lpFormat, ap );                                                                                                \
-        va_end( ap );                                                                                                                   \
-}                                                                                                                                                       \
-name::name( int nCode ) throw() :                                                                                       \
-        ExceptionBase( nCode )                                                                                                  \
-{                                                                                                                                                       \
-}                                                                                                                                                       \
-name::name( const name &e ) throw() :                                                                           \
-        ExceptionBase( e )                                                                                                              \
-{                                                                                                                                                       \
+#define subExceptionDef( name )                                             \
+name::name( const char *lpFormat, ... ) throw() :                           \
+    ExceptionBase( 0 )                                                      \
+{                                                                           \
+    va_list ap;                                                             \
+    va_start( ap, lpFormat );                                               \
+    setWhat( lpFormat, ap );                                                \
+    va_end( ap );                                                           \
+}                                                                           \
+name::name( int nCode, const char *lpFormat, ... ) throw() :                \
+    ExceptionBase( nCode )                                                  \
+{                                                                           \
+    va_list ap;                                                             \
+    va_start( ap, lpFormat );                                               \
+    setWhat( lpFormat, ap );                                                \
+    va_end( ap );                                                           \
+}                                                                           \
+name::name( int nCode ) throw() :                                           \
+    ExceptionBase( nCode )                                                  \
+{                                                                           \
+}                                                                           \
+name::name( const name &e ) throw() :                                       \
+    ExceptionBase( e )                                                      \
+{                                                                           \
 }
 
-#define subExceptionDefChild( name, parent )                                                            \
-name::name( const char *lpFormat, ... ) throw() :                                                       \
-        parent( 0 )                                                                                                                             \
-{                                                                                                                                                       \
-        va_list ap;                                                                                                                             \
-        va_start( ap, lpFormat );                                                                                               \
-        setWhat( lpFormat, ap );                                                                                                \
-        va_end( ap );                                                                                                                   \
-}                                                                                                                                                       \
-name::name( int nCode, const char *lpFormat, ... ) throw() :                            \
-        parent( nCode )                                                                                                                 \
-{                                                                                                                                                       \
-        va_list ap;                                                                                                                             \
-        va_start( ap, lpFormat );                                                                                               \
-        setWhat( lpFormat, ap );                                                                                                \
-        va_end( ap );                                                                                                                   \
-}                                                                                                                                                       \
-name::name( int nCode ) throw() :                                                                                       \
-        parent( nCode )                                                                                                                 \
-{                                                                                                                                                       \
-}                                                                                                                                                       \
-name::name( const name &e ) throw() :                                                                           \
-        ExceptionBase( e )                                                                                                              \
-{                                                                                                                                                       \
+#define subExceptionDefChild( name, parent )                                \
+name::name( const char *lpFormat, ... ) throw() :                           \
+    parent( 0 )                                                             \
+{                                                                           \
+    va_list ap;                                                             \
+    va_start( ap, lpFormat );                                               \
+    setWhat( lpFormat, ap );                                                \
+    va_end( ap );                                                           \
+}                                                                           \
+name::name( int nCode, const char *lpFormat, ... ) throw() :                \
+    parent( nCode )                                                         \
+{                                                                           \
+    va_list ap;                                                             \
+    va_start( ap, lpFormat );                                               \
+    setWhat( lpFormat, ap );                                                \
+    va_end( ap );                                                           \
+}                                                                           \
+name::name( int nCode ) throw() :                                           \
+    parent( nCode )                                                         \
+{                                                                           \
+}                                                                           \
+name::name( const name &e ) throw() :                                       \
+    ExceptionBase( e )                                                      \
+{                                                                           \
 }
 
 namespace Bu
 {
-        // Exceptions that are so general they could be used anywhere go here.
-        class UnsupportedException : public Bu::ExceptionBase
-        {
-        public:
-                UnsupportedException() throw ();
-        };
+    // Exceptions that are so general they could be used anywhere go here.
+    class UnsupportedException : public Bu::ExceptionBase
+    {
+    public:
+        UnsupportedException() throw ();
+    };
 }
 
 #endif
diff --git a/src/stable/extratypes.h b/src/stable/extratypes.h
index 2961920..3549529 100644
--- a/src/stable/extratypes.h
+++ b/src/stable/extratypes.h
@@ -19,11 +19,11 @@
 namespace Bu
 {
 #ifdef USE_64BIT_IO
-        typedef int64_t         size;
-        typedef uint64_t        usize;
+    typedef int64_t     size;
+    typedef uint64_t    usize;
 #else
-        typedef int32_t         size;
-        typedef uint32_t        usize;
+    typedef int32_t     size;
+    typedef uint32_t    usize;
 #endif
 };
 
diff --git a/src/stable/file.cpp b/src/stable/file.cpp
index 14e4f3c..7ae2484 100644
--- a/src/stable/file.cpp
+++ b/src/stable/file.cpp
@@ -19,298 +19,298 @@
 namespace Bu { subExceptionDef( FileException ) }
 
 Bu::File::File( const Bu::String &sName, int iFlags ) :
-        fd( -1 ),
-        bEos( true )
+    fd( -1 ),
+    bEos( true )
 {
 #ifdef USE_64BIT_IO
-        fd = ::open64( sName.getStr(), getPosixFlags( iFlags ), 0666 );
+    fd = ::open64( sName.getStr(), getPosixFlags( iFlags ), 0666 );
 #else
-        fd = ::open( sName.getStr(), getPosixFlags( iFlags ), 0666 );
+    fd = ::open( sName.getStr(), getPosixFlags( iFlags ), 0666 );
 #endif
-        if( fd < 0 )
-        {
-                throw Bu::FileException( errno, "%s: %s",
-                        strerror(errno), sName.getStr() );
-        }
-        bEos = false;
+    if( fd < 0 )
+    {
+        throw Bu::FileException( errno, "%s: %s",
+            strerror(errno), sName.getStr() );
+    }
+    bEos = false;
 }
 
 Bu::File::File( int fd ) :
-        fd( fd )
+    fd( fd )
 {
-        bEos = false;
+    bEos = false;
 }
 
 Bu::File::~File()
 {
-        close();
+    close();
 }
 
 void Bu::File::close()
 {
-        if( fd >= 0 )
-        {
-                if( ::close( fd ) )
-                {
-                        throw Bu::FileException( errno, "%s",
-                                strerror(errno) );
-                }
-                fd = -1;
-                bEos = true;
-        }
+    if( fd >= 0 )
+    {
+        if( ::close( fd ) )
+        {
+            throw Bu::FileException( errno, "%s",
+                strerror(errno) );
+        }
+        fd = -1;
+        bEos = true;
+    }
 }
 
 Bu::size Bu::File::read( void *pBuf, Bu::size nBytes )
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
-
-        Bu::size iRead = ::read( fd, pBuf, nBytes );
-        if( iRead == 0 )
-                bEos = true;
-        else if( iRead == -1 && errno == EAGAIN )
-                return 0;
-        else if( iRead < 0 )
-                throw FileException( errno, "%s", strerror( errno ) );
-        return iRead;
+    if( fd < 0 )
+        throw FileException("File not open.");
+
+    Bu::size iRead = ::read( fd, pBuf, nBytes );
+    if( iRead == 0 )
+        bEos = true;
+    else if( iRead == -1 && errno == EAGAIN )
+        return 0;
+    else if( iRead < 0 )
+        throw FileException( errno, "%s", strerror( errno ) );
+    return iRead;
 }
 
 Bu::size Bu::File::write( const void *pBuf, Bu::size nBytes )
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
+    if( fd < 0 )
+        throw FileException("File not open.");
 
-        Bu::size iWrote = ::write( fd, pBuf, nBytes );
-        if( iWrote < 0 )
-                throw FileException( errno, "%s", strerror( errno ) );
-        return iWrote;
+    Bu::size iWrote = ::write( fd, pBuf, nBytes );
+    if( iWrote < 0 )
+        throw FileException( errno, "%s", strerror( errno ) );
+    return iWrote;
 }
 
 Bu::size Bu::File::tell()
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
+    if( fd < 0 )
+        throw FileException("File not open.");
 
 #ifdef USE_64BIT_IO
-        return lseek64( fd, 0, SEEK_CUR );
+    return lseek64( fd, 0, SEEK_CUR );
 #else
-        return lseek( fd, 0, SEEK_CUR );
+    return lseek( fd, 0, SEEK_CUR );
 #endif
 }
 
 void Bu::File::seek( Bu::size offset )
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
+    if( fd < 0 )
+        throw FileException("File not open.");
 
 #ifdef USE_64BIT_IO
-        lseek64( fd, offset, SEEK_CUR );
+    lseek64( fd, offset, SEEK_CUR );
 #else
-        lseek( fd, offset, SEEK_CUR );
+    lseek( fd, offset, SEEK_CUR );
 #endif
-        bEos = false;
+    bEos = false;
 }
 
 void Bu::File::setPos( Bu::size pos )
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
+    if( fd < 0 )
+        throw FileException("File not open.");
 
 #ifdef USE_64BIT_IO
-        lseek64( fd, pos, SEEK_SET );
+    lseek64( fd, pos, SEEK_SET );
 #else
-        lseek( fd, pos, SEEK_SET );
+    lseek( fd, pos, SEEK_SET );
 #endif
-        bEos = false;
+    bEos = false;
 }
 
 void Bu::File::setPosEnd( Bu::size pos )
 {
-        if( fd < 0 )
-                throw FileException("File not open.");
-        
-        lseek64( fd, pos, SEEK_END );
-        bEos = false;
+    if( fd < 0 )
+        throw FileException("File not open.");
+    
+    lseek64( fd, pos, SEEK_END );
+    bEos = false;
 }
 
 bool Bu::File::isEos()
 {
-        return bEos;
+    return bEos;
 }
 
 bool Bu::File::canRead()
 {
 #ifdef WIN32
-        return true;
+    return true;
 #else
-        int iMode = fcntl( fd, F_GETFL, 0 )&O_ACCMODE;
-        if( iMode == O_RDONLY || iMode == O_RDWR )
-                return true;
-        return false;
+    int iMode = fcntl( fd, F_GETFL, 0 )&O_ACCMODE;
+    if( iMode == O_RDONLY || iMode == O_RDWR )
+        return true;
+    return false;
 #endif
 }
 
 bool Bu::File::canWrite()
 {
 #ifdef WIN32
-        return true;
+    return true;
 #else
-        int iMode = fcntl( fd, F_GETFL, 0 )&O_ACCMODE;
-        if( iMode == O_WRONLY || iMode == O_RDWR )
-                return true;
-        return false;
+    int iMode = fcntl( fd, F_GETFL, 0 )&O_ACCMODE;
+    if( iMode == O_WRONLY || iMode == O_RDWR )
+        return true;
+    return false;
 #endif
 }
 
 bool Bu::File::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::File::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::File::isSeekable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::File::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::File::setBlocking( bool bBlocking )
 {
 #ifdef WIN32
-        fprintf(stderr, "STUB: Bu::File::setBlocking\n");
+    fprintf(stderr, "STUB: Bu::File::setBlocking\n");
 #else
-        if( bBlocking )
-                fcntl( 
-                        fd,
-                        F_SETFL, fcntl( fd, F_GETFL, 0 )&(~O_NONBLOCK)
-                        );
-        else
-                fcntl( 
-                        fd,
-                        F_SETFL, fcntl( fd, F_GETFL, 0 )|O_NONBLOCK
-                        );
+    if( bBlocking )
+        fcntl( 
+            fd,
+            F_SETFL, fcntl( fd, F_GETFL, 0 )&(~O_NONBLOCK)
+            );
+    else
+        fcntl( 
+            fd,
+            F_SETFL, fcntl( fd, F_GETFL, 0 )|O_NONBLOCK
+            );
 #endif
 }
 
 Bu::File Bu::File::tempFile( Bu::String &sName )
 {
-        int iXes;
-        for( iXes = sName.getSize()-1; iXes >= 0; iXes-- )
-        {
-                if( sName[iXes] != 'X' )
-                        break;
-        }
-        iXes++;
-        if( iXes == sName.getSize() )
-                throw Bu::ExceptionBase("Invalid temporary filename template.");
-        for( int iter = 0; iter < 1000; iter++ )
-        {
-                for( int j = iXes; j < sName.getSize(); j++ )
-                {
-                        uint32_t iX = Bu::Random::rand();
-                        sName[j] = ('A'+(iX%26)) | ((iX&0x1000)?(0x20):(0));
-                }
-
-                try
-                {
-                        return Bu::File( sName, Bu::File::Read|Bu::File::Write
-                                        |Bu::File::Create|Bu::File::Exclusive );
-                } catch(...) { }
-        }
-        throw Bu::FileException("Failed to create unique temporary file after 1000"
-                        " iterations.");
+    int iXes;
+    for( iXes = sName.getSize()-1; iXes >= 0; iXes-- )
+    {
+        if( sName[iXes] != 'X' )
+            break;
+    }
+    iXes++;
+    if( iXes == sName.getSize() )
+        throw Bu::ExceptionBase("Invalid temporary filename template.");
+    for( int iter = 0; iter < 1000; iter++ )
+    {
+        for( int j = iXes; j < sName.getSize(); j++ )
+        {
+            uint32_t iX = Bu::Random::rand();
+            sName[j] = ('A'+(iX%26)) | ((iX&0x1000)?(0x20):(0));
+        }
+
+        try
+        {
+            return Bu::File( sName, Bu::File::Read|Bu::File::Write
+                    |Bu::File::Create|Bu::File::Exclusive );
+        } catch(...) { }
+    }
+    throw Bu::FileException("Failed to create unique temporary file after 1000"
+            " iterations.");
 }
 
 void Bu::File::setSize( Bu::size iSize )
 {
 #ifdef WIN32
-        chsize( fd, iSize );
+    chsize( fd, iSize );
 #else
-        ftruncate( fd, iSize );
+    ftruncate( fd, iSize );
 #endif
 }
 
 Bu::size Bu::File::getSize() const
 {
-        struct stat st;
-        fstat( fd, &st );
-        return st.st_size;
+    struct stat st;
+    fstat( fd, &st );
+    return st.st_size;
 }
 
 Bu::size Bu::File::getBlockSize() const
 {
 #ifdef WIN32
-        return 4096;
+    return 4096;
 #else
-        struct stat st;
-        fstat( fd, &st );
-        return st.st_blksize;
+    struct stat st;
+    fstat( fd, &st );
+    return st.st_blksize;
 #endif
 }
 
 Bu::String Bu::File::getLocation() const
 {
-        return "to be implemented";
+    return "to be implemented";
 }
 
 #ifndef WIN32
 void Bu::File::chmod( mode_t t )
 {
-        fchmod( fd, t );
+    fchmod( fd, t );
 }
 #endif
 
 void Bu::File::flush()
 {
-        // There is no flushing with direct I/O...
-        //fflush( fh );
+    // There is no flushing with direct I/O...
+    //fflush( fh );
 }
 
 bool Bu::File::isOpen()
 {
-        return (fd > -1);
+    return (fd > -1);
 }
 
 int Bu::File::getPosixFlags( int iFlags )
 {
-        int iRet = 0;
-        switch( (iFlags&ReadWrite) )
-        {
-                // According to posix, O_RDWR is not necesarilly O_RDONLY|O_WRONLY, so
-                // lets be proper and use the right value in the right place.
-                case Read:              iRet = O_RDONLY; break;
-                case Write:             iRet = O_WRONLY; break;
-                case ReadWrite: iRet = O_RDWR; break;
-                default:
-                        throw FileException(
-                                "You must specify Read, Write, or both when opening a file.");
-        }
-
-        if( (iFlags&Create) )
-                iRet |= O_CREAT;
-        if( (iFlags&Append) )
-                iRet |= O_APPEND;
-        if( (iFlags&Truncate) )
-                iRet |= O_TRUNC;
+    int iRet = 0;
+    switch( (iFlags&ReadWrite) )
+    {
+        // According to posix, O_RDWR is not necesarilly O_RDONLY|O_WRONLY, so
+        // lets be proper and use the right value in the right place.
+        case Read:      iRet = O_RDONLY; break;
+        case Write:     iRet = O_WRONLY; break;
+        case ReadWrite: iRet = O_RDWR; break;
+        default:
+            throw FileException(
+                "You must specify Read, Write, or both when opening a file.");
+    }
+
+    if( (iFlags&Create) )
+        iRet |= O_CREAT;
+    if( (iFlags&Append) )
+        iRet |= O_APPEND;
+    if( (iFlags&Truncate) )
+        iRet |= O_TRUNC;
 #ifndef WIN32
-        if( (iFlags&NonBlock) )
-                iRet |= O_NONBLOCK;
+    if( (iFlags&NonBlock) )
+        iRet |= O_NONBLOCK;
 #endif
-        if( (iFlags&Exclusive) == Exclusive )
-                iRet |= O_EXCL;
+    if( (iFlags&Exclusive) == Exclusive )
+        iRet |= O_EXCL;
 
 #ifdef O_BINARY
-        iRet |= O_BINARY;
+    iRet |= O_BINARY;
 #endif
 
-        return iRet;
+    return iRet;
 }
 
diff --git a/src/stable/file.h b/src/stable/file.h
index eaf2974..2ecb27e 100644
--- a/src/stable/file.h
+++ b/src/stable/file.h
@@ -17,90 +17,90 @@
 
 namespace Bu
 {
-        subExceptionDecl( FileException );
-
-        /**
-         * A file stream.
-         *@ingroup Streams
-         */
-        class File : public Bu::Stream
-        {
-        public:
-                File( const Bu::String &sName, int iFlags );
-                File( int fd );
-                virtual ~File();
-
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
-
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-
-                virtual void flush();
-
-                virtual bool canRead();
-                virtual bool canWrite();
-
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-
-                enum {
-                        // Flags
-                        Read            = 0x01, ///< Open file for reading
-                        Write           = 0x02, ///< Open file for writing
-                        Create          = 0x04, ///< Create file if it doesn't exist
-                        Truncate        = 0x08, ///< Truncate file if it does exist
-                        Append          = 0x10, ///< Always append on every write
-                        NonBlock        = 0x20, ///< Open file in non-blocking mode
-                        Exclusive       = 0x44, ///< Create file, if it exists then fail
-
-                        // Helpful mixes
-                        ReadWrite       = 0x03, ///< Open for reading and writing
-                        WriteNew        = 0x0E  ///< Create a file (or truncate) for writing.
-                                                                /// Same as Write|Create|Truncate
-                };
-
-                virtual void setSize( Bu::size iSize );
-
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-
-                /**
-                 * Create a temp file and return its handle.  The file is opened 
-                 * Read/Write.
-                 *@param sName (Bu::String) Give in the form: "/tmp/tmpfileXXXXXXXX"
-                 *              It will alter your (sName) setting the 'X's to random
-                 *              characters.
-                 *@returns (Bu::File) A file object representing your temp file.
-                 */
-                static Bu::File tempFile( Bu::String &sName );
+    subExceptionDecl( FileException );
+
+    /**
+     * A file stream.
+     *@ingroup Streams
+     */
+    class File : public Bu::Stream
+    {
+    public:
+        File( const Bu::String &sName, int iFlags );
+        File( int fd );
+        virtual ~File();
+
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
+
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+
+        virtual void flush();
+
+        virtual bool canRead();
+        virtual bool canWrite();
+
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+
+        enum {
+            // Flags
+            Read        = 0x01, ///< Open file for reading
+            Write       = 0x02, ///< Open file for writing
+            Create      = 0x04, ///< Create file if it doesn't exist
+            Truncate    = 0x08, ///< Truncate file if it does exist
+            Append      = 0x10, ///< Always append on every write
+            NonBlock    = 0x20, ///< Open file in non-blocking mode
+            Exclusive   = 0x44, ///< Create file, if it exists then fail
+
+            // Helpful mixes
+            ReadWrite   = 0x03, ///< Open for reading and writing
+            WriteNew    = 0x0E  ///< Create a file (or truncate) for writing.
+                                /// Same as Write|Create|Truncate
+        };
+
+        virtual void setSize( Bu::size iSize );
+
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+
+        /**
+         * Create a temp file and return its handle.  The file is opened 
+         * Read/Write.
+         *@param sName (Bu::String) Give in the form: "/tmp/tmpfileXXXXXXXX"
+         *      It will alter your (sName) setting the 'X's to random
+         *      characters.
+         *@returns (Bu::File) A file object representing your temp file.
+         */
+        static Bu::File tempFile( Bu::String &sName );
 
 #ifndef WIN32
-                /**
-                 * Change the file access permissions.
-                 *@param t (mode_t) The new file access permissions.
-                 */
-                void chmod( mode_t t );
+        /**
+         * Change the file access permissions.
+         *@param t (mode_t) The new file access permissions.
+         */
+        void chmod( mode_t t );
 #endif
 
-        private:
-                int getPosixFlags( int iFlags );
+    private:
+        int getPosixFlags( int iFlags );
 
-        private:
-                int fd;
-                bool bEos;
-        };
+    private:
+        int fd;
+        bool bEos;
+    };
 }
 
 #endif
diff --git a/src/stable/filter.cpp b/src/stable/filter.cpp
index 9c1d66f..e7929e7 100644
--- a/src/stable/filter.cpp
+++ b/src/stable/filter.cpp
@@ -8,7 +8,7 @@
 #include "bu/filter.h"
 
 Bu::Filter::Filter( Bu::Stream &rNext ) :
-        rNext( rNext )
+    rNext( rNext )
 {
 }
 
@@ -18,73 +18,73 @@ Bu::Filter::~Filter()
 
 void Bu::Filter::close()
 {
-        stop();
-        rNext.close();
+    stop();
+    rNext.close();
 }
 
 Bu::size Bu::Filter::tell()
 {
-        return rNext.tell();
+    return rNext.tell();
 }
 
 void Bu::Filter::seek( Bu::size offset )
 {
-        rNext.seek( offset );
+    rNext.seek( offset );
 }
 
 void Bu::Filter::setPos( Bu::size pos )
 {
-        rNext.setPos( pos );
+    rNext.setPos( pos );
 }
 
 void Bu::Filter::setPosEnd( Bu::size pos )
 {
-        rNext.setPosEnd( pos );
+    rNext.setPosEnd( pos );
 }
 
 bool Bu::Filter::isEos()
 {
-        return rNext.isEos();
+    return rNext.isEos();
 }
 
 bool Bu::Filter::isOpen()
 {
-        return rNext.isOpen();
+    return rNext.isOpen();
 }
 
 bool Bu::Filter::canRead()
 {
-        return rNext.canRead();
+    return rNext.canRead();
 }
 
 bool Bu::Filter::canWrite()
 {
-        return rNext.canWrite();
+    return rNext.canWrite();
 }
 
 bool Bu::Filter::isReadable()
 {
-        return rNext.isReadable();
+    return rNext.isReadable();
 }
 
 bool Bu::Filter::isWritable()
 {
-        return rNext.isWritable();
+    return rNext.isWritable();
 }
 
 bool Bu::Filter::isSeekable()
 {
-        return rNext.isSeekable();
+    return rNext.isSeekable();
 }
 
 bool Bu::Filter::isBlocking()
 {
-        return rNext.isBlocking();
+    return rNext.isBlocking();
 }
 
 void Bu::Filter::setBlocking( bool bBlocking )
 {
-        rNext.setBlocking( bBlocking );
+    rNext.setBlocking( bBlocking );
 }
 
 void Bu::Filter::setSize( Bu::size )
@@ -93,21 +93,21 @@ void Bu::Filter::setSize( Bu::size )
 
 void Bu::Filter::flush()
 {
-        rNext.flush();
+    rNext.flush();
 }
 
 Bu::size Bu::Filter::getSize() const
 {
-        return rNext.getSize();
+    return rNext.getSize();
 }
 
 Bu::size Bu::Filter::getBlockSize() const
 {
-        return rNext.getBlockSize();
+    return rNext.getBlockSize();
 }
 
 Bu::String Bu::Filter::getLocation() const
 {
-        return rNext.getLocation();
+    return rNext.getLocation();
 }
 
diff --git a/src/stable/filter.h b/src/stable/filter.h
index 3e1c7d8..49a6664 100644
--- a/src/stable/filter.h
+++ b/src/stable/filter.h
@@ -14,70 +14,70 @@
 
 namespace Bu
 {
-        /**
-         * Data filter base class.  Each data filter should contain a read and write
-         * section.  Effectively, the write applies the filter, the read un-applies
-         * the filter, if possible.  For example, BZip2 is a filter that compresses
-         * on write and decompresses on read.  All bi-directional filters should
-         * follow:  x == read( write( x ) ) (byte-for-byte comparison)
-         *
-         * Also, all returned buffers should be owned by the filter, and deleted
-         * when the filter is deleted.  This means that the output of a read or
-         * write operation must be used before the next call to read or write or the
-         * data will be destroyed.  Also, the internal buffer may be changed or
-         * recreated between calls, so always get a new pointer from a call to
-         * read or write.
-         *
-         * The close function can also return data, so make sure to check for it,
-         * many filters such as compression filters will buffer data until they have
-         * enough to create a compression block, in these cases the leftover data
-         * will be returned by close.
-         *@ingroup Streams
-         */
-        class Filter : public Bu::Stream
-        {
-        public:
-                Filter( Bu::Stream &rNext );
-                virtual ~Filter();
+    /**
+     * Data filter base class.  Each data filter should contain a read and write
+     * section.  Effectively, the write applies the filter, the read un-applies
+     * the filter, if possible.  For example, BZip2 is a filter that compresses
+     * on write and decompresses on read.  All bi-directional filters should
+     * follow:  x == read( write( x ) ) (byte-for-byte comparison)
+     *
+     * Also, all returned buffers should be owned by the filter, and deleted
+     * when the filter is deleted.  This means that the output of a read or
+     * write operation must be used before the next call to read or write or the
+     * data will be destroyed.  Also, the internal buffer may be changed or
+     * recreated between calls, so always get a new pointer from a call to
+     * read or write.
+     *
+     * The close function can also return data, so make sure to check for it,
+     * many filters such as compression filters will buffer data until they have
+     * enough to create a compression block, in these cases the leftover data
+     * will be returned by close.
+     *@ingroup Streams
+     */
+    class Filter : public Bu::Stream
+    {
+    public:
+        Filter( Bu::Stream &rNext );
+        virtual ~Filter();
 
-                virtual void start()=0;
-                virtual Bu::size stop()=0;
-                virtual void close();
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
+        virtual void start()=0;
+        virtual Bu::size stop()=0;
+        virtual void close();
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
 
-                virtual void flush();
+        virtual void flush();
 
-                virtual bool canRead();
-                virtual bool canWrite();
+        virtual bool canRead();
+        virtual bool canWrite();
 
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
 
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
 
-                /**
-                 * Most filters won't re-implement this, it doesn't make a lot of sense
-                 * for filters, in general.
-                 */
-                virtual void setSize( Bu::size iSize );
+        /**
+         * Most filters won't re-implement this, it doesn't make a lot of sense
+         * for filters, in general.
+         */
+        virtual void setSize( Bu::size iSize );
 
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-                
-        protected:
-                Bu::Stream &rNext;
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+        
+    protected:
+        Bu::Stream &rNext;
 
-        private:
+    private:
 
-        };
+    };
 }
 
 #endif
diff --git a/src/stable/fmt.h b/src/stable/fmt.h
index bcc5240..9ecaf80 100644
--- a/src/stable/fmt.h
+++ b/src/stable/fmt.h
@@ -3,92 +3,92 @@
 
 namespace Bu
 {
-        typedef struct Fmt
-        {
-                enum Alignment
-                {
-                        Left    = 0,
-                        Center  = 1,
-                        Right   = 2
-                };
-                Fmt() :
-                        uMinWidth( 0 ),
-                        cFillChar(' '),
-                        uRadix( 10 ),
-                        uAlign( Right ),
-                        bPlus( false ),
-                        bCaps( false ),
-                        bTokenize( true )
-                {
-                }
+    typedef struct Fmt
+    {
+        enum Alignment
+        {
+            Left    = 0,
+            Center  = 1,
+            Right   = 2
+        };
+        Fmt() :
+            uMinWidth( 0 ),
+            cFillChar(' '),
+            uRadix( 10 ),
+            uAlign( Right ),
+            bPlus( false ),
+            bCaps( false ),
+            bTokenize( true )
+        {
+        }
 
-                Fmt( unsigned int uMinWidth, unsigned int uRadix=10,
-                                Alignment a=Right, bool bPlus=false, bool bCaps=true,
-                                char cFill=' ') :
-                        uMinWidth( uMinWidth ),
-                        cFillChar(cFill),
-                        uRadix( uRadix ),
-                        uAlign( a ),
-                        bPlus( bPlus ),
-                        bCaps( bCaps ),
-                        bTokenize( true )
-                {
-                }
-                Fmt( unsigned int uMinWidth, Alignment a,
-                                unsigned int uRadix=10, bool bPlus=false, bool bCaps=true,
-                                char cFill=' ') :
-                        uMinWidth( uMinWidth ),
-                        cFillChar(cFill),
-                        uRadix( uRadix ),
-                        uAlign( a ),
-                        bPlus( bPlus ),
-                        bCaps( bCaps ),
-                        bTokenize( true )
-                {
-                }
+        Fmt( unsigned int uMinWidth, unsigned int uRadix=10,
+                Alignment a=Right, bool bPlus=false, bool bCaps=true,
+                char cFill=' ') :
+            uMinWidth( uMinWidth ),
+            cFillChar(cFill),
+            uRadix( uRadix ),
+            uAlign( a ),
+            bPlus( bPlus ),
+            bCaps( bCaps ),
+            bTokenize( true )
+        {
+        }
+        Fmt( unsigned int uMinWidth, Alignment a,
+                unsigned int uRadix=10, bool bPlus=false, bool bCaps=true,
+                char cFill=' ') :
+            uMinWidth( uMinWidth ),
+            cFillChar(cFill),
+            uRadix( uRadix ),
+            uAlign( a ),
+            bPlus( bPlus ),
+            bCaps( bCaps ),
+            bTokenize( true )
+        {
+        }
 
-                static Fmt hex( unsigned int uWidth=0, bool bCaps=false )
-                {
-                        return Fmt( uWidth, 16, Right, false, bCaps, '0' );
-                }
-                
-                static Fmt oct( unsigned int uWidth=0 )
-                {
-                        return Fmt( uWidth, 8, Right, false, false, '0' );
-                }
+        static Fmt hex( unsigned int uWidth=0, bool bCaps=false )
+        {
+            return Fmt( uWidth, 16, Right, false, bCaps, '0' );
+        }
+        
+        static Fmt oct( unsigned int uWidth=0 )
+        {
+            return Fmt( uWidth, 8, Right, false, false, '0' );
+        }
 
-                static Fmt bin( unsigned int uWidth=0 )
-                {
-                        return Fmt( uWidth, 1, Right, false, false, '0' );
-                }
+        static Fmt bin( unsigned int uWidth=0 )
+        {
+            return Fmt( uWidth, 1, Right, false, false, '0' );
+        }
 
-                static Fmt ptr( bool bCaps=true )
-                {
-                        return Fmt( sizeof(ptrdiff_t)*2, 16, Right, false, bCaps, '0' );
-                }
+        static Fmt ptr( bool bCaps=true )
+        {
+            return Fmt( sizeof(ptrdiff_t)*2, 16, Right, false, bCaps, '0' );
+        }
 
-                Fmt &width( unsigned int uWidth );
-                Fmt &fill( char cFill='0' );
-                Fmt &radix( unsigned int uRadix );
-                Fmt &align( Alignment eAlign );
-                Fmt &plus( bool bPlus=true );
-                Fmt &caps( bool bCaps=true );
-                Fmt &upper();
-                Fmt &lower();
-                Fmt &tokenize( bool bTokenize=true );
+        Fmt &width( unsigned int uWidth );
+        Fmt &fill( char cFill='0' );
+        Fmt &radix( unsigned int uRadix );
+        Fmt &align( Alignment eAlign );
+        Fmt &plus( bool bPlus=true );
+        Fmt &caps( bool bCaps=true );
+        Fmt &upper();
+        Fmt &lower();
+        Fmt &tokenize( bool bTokenize=true );
 
-                Fmt &left();
-                Fmt &right();
-                Fmt &center();
+        Fmt &left();
+        Fmt &right();
+        Fmt &center();
 
-                unsigned char uMinWidth;
-                char cFillChar;
-                unsigned short uRadix : 6;
-                unsigned short uAlign : 2;
-                unsigned short bPlus : 1;
-                unsigned short bCaps : 1;
-                unsigned short bTokenize : 1;
-        } Fmt;
+        unsigned char uMinWidth;
+        char cFillChar;
+        unsigned short uRadix : 6;
+        unsigned short uAlign : 2;
+        unsigned short bPlus : 1;
+        unsigned short bCaps : 1;
+        unsigned short bTokenize : 1;
+    } Fmt;
 };
 
 #endif
diff --git a/src/stable/formatter.cpp b/src/stable/formatter.cpp
index a04f7a6..9a42c99 100644
--- a/src/stable/formatter.cpp
+++ b/src/stable/formatter.cpp
@@ -12,54 +12,54 @@
 
 template<> float Bu::tlog( float x )
 {
-        return logf( x );
+    return logf( x );
 }
 
 template<> double Bu::tlog( double x )
 {
-        return log( x );
+    return log( x );
 }
 
 template<> long double Bu::tlog( long double x )
 {
-        return logl( x );
+    return logl( x );
 }
 
 template<> float Bu::tfloor( float x )
 {
-        return floorf( x );
+    return floorf( x );
 }
 
 template<> double Bu::tfloor( double x )
 {
-        return floor( x );
+    return floor( x );
 }
 
 template<> long double Bu::tfloor( long double x )
 {
-        return floorl( x );
+    return floorl( x );
 }
 
 template<> float Bu::tpow( float x, float y )
 {
-        return powf( x, y );
+    return powf( x, y );
 }
 
 template<> double Bu::tpow( double x, double y )
 {
-        return pow( x, y );
+    return pow( x, y );
 }
 
 template<> long double Bu::tpow( long double x, long double y )
 {
-        return powl( x, y );
+    return powl( x, y );
 }
 
 Bu::Formatter::Formatter( Stream &rStream ) :
-        rStream( rStream ),
-        bTempFmt( false ),
-        uIndent( 0 ),
-        cIndent( '\t' )
+    rStream( rStream ),
+    bTempFmt( false ),
+    uIndent( 0 ),
+    cIndent( '\t' )
 {
 }
 
@@ -69,491 +69,491 @@ Bu::Formatter::~Formatter()
 
 void Bu::Formatter::write( const Bu::String &sStr )
 {
-        rStream.write( sStr );
+    rStream.write( sStr );
 }
 
 void Bu::Formatter::write( const void *sStr, int iLen )
 {
-        rStream.write( sStr, iLen );
+    rStream.write( sStr, iLen );
 }
 
 void Bu::Formatter::writeAligned( const Bu::String &sStr )
 {
-        int iLen = sStr.getSize();
-        if( iLen > fLast.uMinWidth )
-        {
-                write( sStr );
-        }
-        else
-        {
-                int iRem = fLast.uMinWidth - iLen;
-                switch( fLast.uAlign )
-                {
-                        case Fmt::Right:
-                                for( int k = 0; k < iRem; k++ )
-                                        write( &fLast.cFillChar, 1 );
-                                write( sStr );
-                                break;
-                        
-                        case Fmt::Center:
-                                {
-                                        int iHlf = iRem/2;
-                                        for( int k = 0; k < iHlf; k++ )
-                                                write( &fLast.cFillChar, 1 );
-                                        write( sStr );
-                                        iHlf = iRem-iHlf;;
-                                        for( int k = 0; k < iHlf; k++ )
-                                                write( &fLast.cFillChar, 1 );
-                                }
-                                break;
-                        
-                        case Fmt::Left:
-                                write( sStr );
-                                for( int k = 0; k < iRem; k++ )
-                                        write( &fLast.cFillChar, 1 );
-                                break;
-                }
-        }
-
-        usedFormat();
+    int iLen = sStr.getSize();
+    if( iLen > fLast.uMinWidth )
+    {
+        write( sStr );
+    }
+    else
+    {
+        int iRem = fLast.uMinWidth - iLen;
+        switch( fLast.uAlign )
+        {
+            case Fmt::Right:
+                for( int k = 0; k < iRem; k++ )
+                    write( &fLast.cFillChar, 1 );
+                write( sStr );
+                break;
+            
+            case Fmt::Center:
+                {
+                    int iHlf = iRem/2;
+                    for( int k = 0; k < iHlf; k++ )
+                        write( &fLast.cFillChar, 1 );
+                    write( sStr );
+                    iHlf = iRem-iHlf;;
+                    for( int k = 0; k < iHlf; k++ )
+                        write( &fLast.cFillChar, 1 );
+                }
+                break;
+            
+            case Fmt::Left:
+                write( sStr );
+                for( int k = 0; k < iRem; k++ )
+                    write( &fLast.cFillChar, 1 );
+                break;
+        }
+    }
+
+    usedFormat();
 }
 
 void Bu::Formatter::writeAligned( const char *sStr, int iLen )
 {
-        if( iLen > fLast.uMinWidth )
-        {
-                write( sStr, iLen );
-        }
-        else
-        {
-                int iRem = fLast.uMinWidth - iLen;
-                switch( fLast.uAlign )
-                {
-                        case Fmt::Right:
-                                for( int k = 0; k < iRem; k++ )
-                                        write( &fLast.cFillChar, 1 );
-                                write( sStr, iLen );
-                                break;
-                        
-                        case Fmt::Center:
-                                {
-                                        int iHlf = iRem/2;
-                                        for( int k = 0; k < iHlf; k++ )
-                                                write( &fLast.cFillChar, 1 );
-                                        write( sStr, iLen );
-                                        iHlf = iRem-iHlf;;
-                                        for( int k = 0; k < iHlf; k++ )
-                                                write( &fLast.cFillChar, 1 );
-                                }
-                                break;
-                        
-                        case Fmt::Left:
-                                write( sStr, iLen );
-                                for( int k = 0; k < iRem; k++ )
-                                        write( &fLast.cFillChar, 1 );
-                                break;
-                }
-        }
-
-        usedFormat();
+    if( iLen > fLast.uMinWidth )
+    {
+        write( sStr, iLen );
+    }
+    else
+    {
+        int iRem = fLast.uMinWidth - iLen;
+        switch( fLast.uAlign )
+        {
+            case Fmt::Right:
+                for( int k = 0; k < iRem; k++ )
+                    write( &fLast.cFillChar, 1 );
+                write( sStr, iLen );
+                break;
+            
+            case Fmt::Center:
+                {
+                    int iHlf = iRem/2;
+                    for( int k = 0; k < iHlf; k++ )
+                        write( &fLast.cFillChar, 1 );
+                    write( sStr, iLen );
+                    iHlf = iRem-iHlf;;
+                    for( int k = 0; k < iHlf; k++ )
+                        write( &fLast.cFillChar, 1 );
+                }
+                break;
+            
+            case Fmt::Left:
+                write( sStr, iLen );
+                for( int k = 0; k < iRem; k++ )
+                    write( &fLast.cFillChar, 1 );
+                break;
+        }
+    }
+
+    usedFormat();
 }
 
 void Bu::Formatter::read( void *sStr, int iLen )
 {
-        rStream.read( sStr, iLen );
+    rStream.read( sStr, iLen );
 }
 
 Bu::String Bu::Formatter::readToken()
 {
-        Bu::String sRet;
-        if( fLast.bTokenize )
-        {
-                for(;;)
-                {
-                        char buf;
-                        int iRead = rStream.read( &buf, 1 );
-                        if( iRead == 0 )
-                                return sRet;
-                        if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
-                                continue;
-                        else
-                        {
-                                sRet += buf;
-                                break;
-                        }
-                }
-                for(;;)
-                {
-                        char buf;
-                        int iRead = rStream.read( &buf, 1 );
-                        if( iRead == 0 )
-                                return sRet;
-                        if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
-                                return sRet;
-                        else
-                                sRet += buf;
-                }
-        }
-        else
-        {
-                for(;;)
-                {
-                        char buf;
-                        int iRead = rStream.read( &buf, 1 );
-                        if( iRead == 0 )
-                                return sRet;
-                        else
-                                sRet += buf;
-                }
-        }
+    Bu::String sRet;
+    if( fLast.bTokenize )
+    {
+        for(;;)
+        {
+            char buf;
+            int iRead = rStream.read( &buf, 1 );
+            if( iRead == 0 )
+                return sRet;
+            if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
+                continue;
+            else
+            {
+                sRet += buf;
+                break;
+            }
+        }
+        for(;;)
+        {
+            char buf;
+            int iRead = rStream.read( &buf, 1 );
+            if( iRead == 0 )
+                return sRet;
+            if( buf == ' ' || buf == '\t' || buf == '\n' || buf == '\r' )
+                return sRet;
+            else
+                sRet += buf;
+        }
+    }
+    else
+    {
+        for(;;)
+        {
+            char buf;
+            int iRead = rStream.read( &buf, 1 );
+            if( iRead == 0 )
+                return sRet;
+            else
+                sRet += buf;
+        }
+    }
 }
 
 void Bu::Formatter::incIndent()
 {
-        if( uIndent < 0xFFU )
-                uIndent++;
+    if( uIndent < 0xFFU )
+        uIndent++;
 }
 
 void Bu::Formatter::decIndent()
 {
-        if( uIndent > 0 )
-                uIndent--;
+    if( uIndent > 0 )
+        uIndent--;
 }
 
 void Bu::Formatter::setIndent( uint8_t uLevel )
 {
-        uIndent = uLevel;
+    uIndent = uLevel;
 }
 
 void Bu::Formatter::clearIndent()
 {
-        uIndent = 0;
+    uIndent = 0;
 }
 
 void Bu::Formatter::setIndentChar( char cIndent )
 {
-        this->cIndent = cIndent;
+    this->cIndent = cIndent;
 }
 
 void Bu::Formatter::doFlush()
 {
-        rStream.flush();
+    rStream.flush();
 }
 
 Bu::Fmt &Bu::Fmt::width( unsigned int uWidth )
 {
-        this->uMinWidth = uWidth;
-        return *this;
+    this->uMinWidth = uWidth;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::fill( char cFill )
 {
-        this->cFillChar = (unsigned char)cFill;
-        return *this;
+    this->cFillChar = (unsigned char)cFill;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::radix( unsigned int uRadix )
 {
-        this->uRadix = uRadix;
-        return *this;
+    this->uRadix = uRadix;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::align( Alignment eAlign )
 {
-        this->uAlign = eAlign;
-        return *this;
+    this->uAlign = eAlign;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::left()
 {
-        this->uAlign = Fmt::Left;
-        return *this;
+    this->uAlign = Fmt::Left;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::center()
 {
-        this->uAlign = Fmt::Center;
-        return *this;
+    this->uAlign = Fmt::Center;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::right()
 {
-        this->uAlign = Fmt::Right;
-        return *this;
+    this->uAlign = Fmt::Right;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::plus( bool bPlus )
 {
-        this->bPlus = bPlus;
-        return *this;
+    this->bPlus = bPlus;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::caps( bool bCaps )
 {
-        this->bCaps = bCaps;
-        return *this;
+    this->bCaps = bCaps;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::upper()
 {
-        this->bCaps = true;
-        return *this;
+    this->bCaps = true;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::lower()
 {
-        this->bCaps = false;
-        return *this;
+    this->bCaps = false;
+    return *this;
 }
 
 Bu::Fmt &Bu::Fmt::tokenize( bool bTokenize )
 {
-        this->bTokenize = bTokenize;
-        return *this;
+    this->bTokenize = bTokenize;
+    return *this;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::Fmt &fmt )
 {
-        f.setTempFormat( fmt );
-        return f;
+    f.setTempFormat( fmt );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, Bu::Formatter::Special s )
 {
-        switch( s )
-        {
-                case Formatter::nl:
-                        {
+    switch( s )
+    {
+        case Formatter::nl:
+            {
 #ifdef WIN32
-                                f.write("\r\n", 2 );
+                f.write("\r\n", 2 );
 #else
-                                f.write("\n", 1 );
+                f.write("\n", 1 );
 #endif
-                                char ci = f.getIndentChar();
-                                for( int j = 0; j < f.getIndent(); j++ )
-                                        f.write( &ci, 1 );
-                                f.doFlush();
-                        }
-                        break;
+                char ci = f.getIndentChar();
+                for( int j = 0; j < f.getIndent(); j++ )
+                    f.write( &ci, 1 );
+                f.doFlush();
+            }
+            break;
 
-                case Formatter::flush:
-                        f.doFlush();
-                        break;
-        }
-        return f;
+        case Formatter::flush:
+            f.doFlush();
+            break;
+    }
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const char *sStr )
 {
-        f.writeAligned( sStr, strlen( sStr ) );
-        return f;
+    f.writeAligned( sStr, strlen( sStr ) );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, char *sStr )
 {
-        f.writeAligned( sStr, strlen( sStr ) );
-        return f;
+    f.writeAligned( sStr, strlen( sStr ) );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::String &sStr )
 {
-        f.writeAligned( sStr );
-        return f;
+    f.writeAligned( sStr );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed char c )
 {
-        f.ifmt<signed char>( c );
-        //f.write( (char *)&c, 1 );
-        return f;
+    f.ifmt<signed char>( c );
+    //f.write( (char *)&c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, char c )
 {
-        f.write( (char *)&c, 1 );
-        return f;
+    f.write( (char *)&c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned char c )
 {
-        f.ufmt<unsigned char>( c );
-        //f.write( (char *)&c, 1 );
-        return f;
+    f.ufmt<unsigned char>( c );
+    //f.write( (char *)&c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed short i )
 {
-        f.ifmt<signed short>( i );
-        return f;
+    f.ifmt<signed short>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned short i )
 {
-        f.ufmt<unsigned short>( i );
-        return f;
+    f.ufmt<unsigned short>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed int i )
 {
-        f.ifmt<signed int>( i );
-        return f;
+    f.ifmt<signed int>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned int i )
 {
-        f.ufmt<unsigned int>( i );
-        return f;
+    f.ufmt<unsigned int>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed long i )
 {
-        f.ifmt<signed long>( i );
-        return f;
+    f.ifmt<signed long>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned long i )
 {
-        f.ufmt<unsigned long>( i );
-        return f;
+    f.ufmt<unsigned long>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, signed long long i )
 {
-        f.ifmt<signed long long>( i );
-        return f;
+    f.ifmt<signed long long>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, unsigned long long i )
 {
-        f.ufmt<unsigned long long>( i );
-        return f;
+    f.ufmt<unsigned long long>( i );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, float flt )
 {
-        f.ffmt<float>( flt );
-        return f;
+    f.ffmt<float>( flt );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, double flt )
 {
-        f.ffmt<double>( flt );
-        return f;
+    f.ffmt<double>( flt );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, long double flt )
 {
-        f.ffmt<long double>( flt );
-        return f;
+    f.ffmt<long double>( flt );
+    return f;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, bool b )
 {
-        f.writeAligned( b?("true"):("false") );
-        return f;
+    f.writeAligned( b?("true"):("false") );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, Bu::String &sStr )
 {
-        sStr = f.readToken();
-        return f;
+    sStr = f.readToken();
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed char &c )
 {
-        f.read( &c, 1 );
-        return f;
+    f.read( &c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, char &c )
 {
-        f.read( &c, 1 );
-        return f;
+    f.read( &c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned char &c )
 {
-        f.read( &c, 1 );
-        return f;
+    f.read( &c, 1 );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed short &i )
 {
-        f.iparse( i, f.readToken() );
-        return f;
+    f.iparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned short &i )
 {
-        f.uparse( i, f.readToken() );
-        return f;
+    f.uparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed int &i )
 {
-        f.iparse( i, f.readToken() );
-        return f;
+    f.iparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned int &i )
 {
-        f.uparse( i, f.readToken() );
-        return f;
+    f.uparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed long &i )
 {
-        f.iparse( i, f.readToken() );
-        return f;
+    f.iparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned long &i )
 {
-        f.uparse( i, f.readToken() );
-        return f;
+    f.uparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, signed long long &i )
 {
-        f.iparse( i, f.readToken() );
-        return f;
+    f.iparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, unsigned long long &i )
 {
-        f.uparse( i, f.readToken() );
-        return f;
+    f.uparse( i, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, float &flt )
 {
-        f.fparse( flt, f.readToken() );
-        return f;
+    f.fparse( flt, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, double &flt )
 {
-        f.fparse( flt, f.readToken() );
-        return f;
+    f.fparse( flt, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, long double &flt )
 {
-        f.fparse( flt, f.readToken() );
-        return f;
+    f.fparse( flt, f.readToken() );
+    return f;
 }
 
 Bu::Formatter &Bu::operator>>( Bu::Formatter &f, bool &b )
 {
-        Bu::String sStr = f.readToken();
-        if( !sStr.isSet() )
-                return f;
-        char c = *sStr.begin();
-        if( c == 'y' || c == 'Y' || c == 't' || c == 'T' )
-                b = true;
-        else if( c == 'n' || c == 'N' || c == 'f' || c == 'F' )
-                b = false;
+    Bu::String sStr = f.readToken();
+    if( !sStr.isSet() )
+        return f;
+    char c = *sStr.begin();
+    if( c == 'y' || c == 'Y' || c == 't' || c == 'T' )
+        b = true;
+    else if( c == 'n' || c == 'N' || c == 'f' || c == 'F' )
+        b = false;
 
-        return f;
+    return f;
 }
 
diff --git a/src/stable/formatter.h b/src/stable/formatter.h
index d92a53b..94794b5 100644
--- a/src/stable/formatter.h
+++ b/src/stable/formatter.h
@@ -15,292 +15,292 @@
 
 namespace Bu
 {
-        class Stream;
-
-        template<typename t> t tlog( t x );
-        template<> float tlog( float x );
-        template<> double tlog( double x );
-        template<> long double tlog( long double x );
-
-        template<typename t> t tfloor( t x );
-        template<> float tfloor( float x );
-        template<> double tfloor( double x );
-        template<> long double tfloor( long double x );
-
-        template<typename t> t tpow( t x, t y );
-        template<> float tpow( float x, float y );
-        template<> double tpow( double x, double y );
-        template<> long double tpow( long double x, long double y );
-
-        class Formatter
-        {
-        public:
-                Formatter( Stream &rStream );
-                virtual ~Formatter();
-
-                void write( const Bu::String &sStr );
-                void write( const void *sStr, int iLen );
-                void writeAligned( const Bu::String &sStr );
-                void writeAligned( const char *sStr, int iLen );
-
-                void read( void *sStr, int iLen );
-                Bu::String readToken();
-
-                void incIndent();
-                void decIndent();
-                void setIndent( uint8_t uLevel );
-                void clearIndent();
-                uint8_t getIndent() const { return uIndent; }
-                void setIndentChar( char cIndent );
-                char getIndentChar() const { return cIndent; }
-
-                void setFormat( const Fmt &f )
-                {
-                        fLast = f;
-                        bTempFmt = false;
-                }
-
-                void setTempFormat( const Fmt &f )
-                {
-                        fLast = f;
-                        bTempFmt = true;
-                }
-
-                void usedFormat()
-                {
-                        if( bTempFmt )
-                                fLast = Fmt();
-                }
-
-                template<typename type>
-                void ifmt( type i )
-                {
-                        // This code is taken from Nango, hopefully we can make it better.
-                        bool bNeg = i<0;
-                        char cBase = fLast.bCaps?'A':'a';
-                        char buf[sizeof(type)*8+1];
-                        if( bNeg ) i = -i;
-                        if( fLast.uRadix < 2 || fLast.uRadix > 36 )
-                        {
-                                usedFormat();
-                                return;
-                        }
-
-                        for( int j = sizeof(type)*8; j >= 0; j-- )
-                        {
-                                int c = i%fLast.uRadix;
-                                i /= fLast.uRadix;
-                                buf[j] = (char)((c<10)?('0'+c):(cBase+c-10));
-                                if( i == 0 )
-                                {
-                                        if( bNeg ) buf[--j] = '-';
-                                        else if( fLast.bPlus ) buf[--j] = '+';
-                                        writeAligned( buf+j, sizeof(type)*8-j+1 );
-
-                                        return;
-                                }
-                        }
-                        usedFormat();
-                }
-
-                template<typename type>
-                void ufmt( type i )
-                {
-                        // This code is taken from Nango, hopefully we can make it better.
-                        char buf[sizeof(type)*8+1];
-                        char cBase = fLast.bCaps?'A':'a';
-                        if( fLast.uRadix < 2 || fLast.uRadix > 36 )
-                        {
-                                usedFormat();
-                                return;
-                        }
-
-                        for( int j = sizeof(type)*8; j >= 0; j-- )
-                        {
-                                int c = i%fLast.uRadix;
-                                i /= fLast.uRadix;
-                                buf[j] = (char)((c<10)?('0'+c):(cBase+c-10));
-                                if( i == 0 )
-                                {
-                                        if( fLast.bPlus ) buf[--j] = '+';
-                                        writeAligned( buf+j, sizeof(type)*8-j+1 );
-
-                                        return;
-                                }
-                        }
-                        usedFormat();
-                }
-
-                template<typename type>
-                void ffmt( type f )
-                {
-                        Bu::String fTmp;
-                        char cBase = fLast.bCaps?'A':'a';
-                        if( fLast.uRadix < 2 || fLast.uRadix > 36 )
-                        {
-                                usedFormat();
-                                return;
-                        }
-
-                        if( signbit(f) )
-                        {
-                                f = -f;
-                                fTmp += "-";
-                        }
-                        int iScale = tfloor(tlog( f ) / tlog( (type)fLast.uRadix ));
-                        f /= tpow( (type)fLast.uRadix, (type)iScale );
-
-                        if( iScale < 0 )
-                        {
-                                fTmp += "0.";
-                                for( int j = 1; j < -iScale; j++ )
-                                        fTmp += '0';
-                        }
-                        int c = f;
-                        fTmp += (char)((c<10)?('0'+c):(cBase+c-10));
-                        f -= (int)f;
-                        int j;
-                        for( j = 0; j < 8 && f; j++ )
-                        {
-                                if( iScale - j == 0 )
-                                        fTmp += '.';
-                                f = f*fLast.uRadix;
-                                int c = f;
-                                fTmp += (char)((c<10)?('0'+c):(cBase+c-10));
-                                f -= (int)f;
-                        }
-                        if( iScale >= j )
-                        {
-                                for( int k = j; k < iScale; k++ )
-                                        fTmp += '0';
-                                fTmp += ".0";
-                        }
-
-                        writeAligned( fTmp );
-                        usedFormat();
-                }
-                
-                template<typename type>
-                void iparse( type &i, const Bu::String &sBuf )
-                {
-                        if( !sBuf.isSet() )
-                                return;
-                        if( sBuf[0] != '+' && sBuf[0] != '-' &&
-                                (sBuf[0] < '0' && sBuf[0] > '9') )
-                                return;
-                        int j = 1;
-                        int iMax = sBuf.getSize();
-                        for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
-                        i = 0;
-                        type iPos = 1;
-                        for(j--; j >= 0; j-- )
-                        {
-                                if( sBuf[j] == '+' || sBuf[j] == '-' )
-                                        continue;
-                                i += (sBuf[j]-'0')*iPos;
-                                iPos *= fLast.uRadix;
-                        }
-                        if( sBuf[0] == '-' )
-                                i = -i;
-
-                        usedFormat();
-                }
-                
-                template<typename type>
-                void uparse( type &i, const Bu::String &sBuf )
-                {
-                        if( !sBuf.isSet() )
-                                return;
-                        if( sBuf[0] != '+' &&
-                                (sBuf[0] < '0' && sBuf[0] > '9') )
-                                return;
-                        int j = 1;
-                        int iMax = sBuf.getSize();
-                        for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
-                        i = 0;
-                        type iPos = 1;
-                        for(j--; j >= 0; j-- )
-                        {
-                                if( sBuf[j] == '+' )
-                                        continue;
-                                i += (sBuf[j]-'0')*iPos;
-                                iPos *= fLast.uRadix;
-                        }
-
-                        usedFormat();
-                }
-                
-                template<typename type>
-                void fparse( type &f, const Bu::String &sBuf )
-                {
-                        double fIn;
-                        sscanf( sBuf.getStr(), "%lf", &fIn );
-                        f = fIn;
-                        usedFormat();
-                }
-
-                enum Special
-                {
-                        nl,
-                        flush
-                };
-
-                void doFlush();
-
-                Stream &getStream() { return rStream; }
-                operator Stream&() { return rStream; }
-
-        private:
-                Stream &rStream;
-                Fmt fLast;
-                bool bTempFmt;
-                uint8_t uIndent;
-                char cIndent;
-        };
-
-        Formatter &operator<<( Formatter &f, const Fmt &fmt );
-        Formatter &operator<<( Formatter &f, Formatter::Special s );
-        Formatter &operator<<( Formatter &f, const char *sStr );
-        Formatter &operator<<( Formatter &f, char *sStr );
-        Formatter &operator<<( Formatter &f, const Bu::String &sStr );
-        Formatter &operator<<( Formatter &f, signed char c );
-        Formatter &operator<<( Formatter &f, char c );
-        Formatter &operator<<( Formatter &f, unsigned char c );
-        Formatter &operator<<( Formatter &f, signed short i );
-        Formatter &operator<<( Formatter &f, unsigned short i );
-        Formatter &operator<<( Formatter &f, signed int i );
-        Formatter &operator<<( Formatter &f, unsigned int i );
-        Formatter &operator<<( Formatter &f, signed long i );
-        Formatter &operator<<( Formatter &f, unsigned long i );
-        Formatter &operator<<( Formatter &f, signed long long i );
-        Formatter &operator<<( Formatter &f, unsigned long long i );
-        Formatter &operator<<( Formatter &f, float flt );
-        Formatter &operator<<( Formatter &f, double flt );
-        Formatter &operator<<( Formatter &f, long double flt );
-        Formatter &operator<<( Formatter &f, bool b );
-
-        Formatter &operator>>( Formatter &f, Bu::String &sStr );
-        Formatter &operator>>( Formatter &f, signed char &c );
-        Formatter &operator>>( Formatter &f, char &c );
-        Formatter &operator>>( Formatter &f, unsigned char &c );
-        Formatter &operator>>( Formatter &f, signed short &i );
-        Formatter &operator>>( Formatter &f, unsigned short &i );
-        Formatter &operator>>( Formatter &f, signed int &i );
-        Formatter &operator>>( Formatter &f, unsigned int &i );
-        Formatter &operator>>( Formatter &f, signed long &i );
-        Formatter &operator>>( Formatter &f, unsigned long &i );
-        Formatter &operator>>( Formatter &f, signed long long &i );
-        Formatter &operator>>( Formatter &f, unsigned long long &i );
-        Formatter &operator>>( Formatter &f, float &flt );
-        Formatter &operator>>( Formatter &f, double &flt );
-        Formatter &operator>>( Formatter &f, long double &flt );
-        Formatter &operator>>( Formatter &f, bool &b );
-
-        template<typename type>
-        Formatter &operator<<( Formatter &f, const type *p )
-        {
-                return f << "0x" << Fmt::hex(sizeof(ptrdiff_t)*2) << (ptrdiff_t)(p);
-        }
+    class Stream;
+
+    template<typename t> t tlog( t x );
+    template<> float tlog( float x );
+    template<> double tlog( double x );
+    template<> long double tlog( long double x );
+
+    template<typename t> t tfloor( t x );
+    template<> float tfloor( float x );
+    template<> double tfloor( double x );
+    template<> long double tfloor( long double x );
+
+    template<typename t> t tpow( t x, t y );
+    template<> float tpow( float x, float y );
+    template<> double tpow( double x, double y );
+    template<> long double tpow( long double x, long double y );
+
+    class Formatter
+    {
+    public:
+        Formatter( Stream &rStream );
+        virtual ~Formatter();
+
+        void write( const Bu::String &sStr );
+        void write( const void *sStr, int iLen );
+        void writeAligned( const Bu::String &sStr );
+        void writeAligned( const char *sStr, int iLen );
+
+        void read( void *sStr, int iLen );
+        Bu::String readToken();
+
+        void incIndent();
+        void decIndent();
+        void setIndent( uint8_t uLevel );
+        void clearIndent();
+        uint8_t getIndent() const { return uIndent; }
+        void setIndentChar( char cIndent );
+        char getIndentChar() const { return cIndent; }
+
+        void setFormat( const Fmt &f )
+        {
+            fLast = f;
+            bTempFmt = false;
+        }
+
+        void setTempFormat( const Fmt &f )
+        {
+            fLast = f;
+            bTempFmt = true;
+        }
+
+        void usedFormat()
+        {
+            if( bTempFmt )
+                fLast = Fmt();
+        }
+
+        template<typename type>
+        void ifmt( type i )
+        {
+            // This code is taken from Nango, hopefully we can make it better.
+            bool bNeg = i<0;
+            char cBase = fLast.bCaps?'A':'a';
+            char buf[sizeof(type)*8+1];
+            if( bNeg ) i = -i;
+            if( fLast.uRadix < 2 || fLast.uRadix > 36 )
+            {
+                usedFormat();
+                return;
+            }
+
+            for( int j = sizeof(type)*8; j >= 0; j-- )
+            {
+                int c = i%fLast.uRadix;
+                i /= fLast.uRadix;
+                buf[j] = (char)((c<10)?('0'+c):(cBase+c-10));
+                if( i == 0 )
+                {
+                    if( bNeg ) buf[--j] = '-';
+                    else if( fLast.bPlus ) buf[--j] = '+';
+                    writeAligned( buf+j, sizeof(type)*8-j+1 );
+
+                    return;
+                }
+            }
+            usedFormat();
+        }
+
+        template<typename type>
+        void ufmt( type i )
+        {
+            // This code is taken from Nango, hopefully we can make it better.
+            char buf[sizeof(type)*8+1];
+            char cBase = fLast.bCaps?'A':'a';
+            if( fLast.uRadix < 2 || fLast.uRadix > 36 )
+            {
+                usedFormat();
+                return;
+            }
+
+            for( int j = sizeof(type)*8; j >= 0; j-- )
+            {
+                int c = i%fLast.uRadix;
+                i /= fLast.uRadix;
+                buf[j] = (char)((c<10)?('0'+c):(cBase+c-10));
+                if( i == 0 )
+                {
+                    if( fLast.bPlus ) buf[--j] = '+';
+                    writeAligned( buf+j, sizeof(type)*8-j+1 );
+
+                    return;
+                }
+            }
+            usedFormat();
+        }
+
+        template<typename type>
+        void ffmt( type f )
+        {
+            Bu::String fTmp;
+            char cBase = fLast.bCaps?'A':'a';
+            if( fLast.uRadix < 2 || fLast.uRadix > 36 )
+            {
+                usedFormat();
+                return;
+            }
+
+            if( signbit(f) )
+            {
+                f = -f;
+                fTmp += "-";
+            }
+            int iScale = tfloor(tlog( f ) / tlog( (type)fLast.uRadix ));
+            f /= tpow( (type)fLast.uRadix, (type)iScale );
+
+            if( iScale < 0 )
+            {
+                fTmp += "0.";
+                for( int j = 1; j < -iScale; j++ )
+                    fTmp += '0';
+            }
+            int c = f;
+            fTmp += (char)((c<10)?('0'+c):(cBase+c-10));
+            f -= (int)f;
+            int j;
+            for( j = 0; j < 8 && f; j++ )
+            {
+                if( iScale - j == 0 )
+                    fTmp += '.';
+                f = f*fLast.uRadix;
+                int c = f;
+                fTmp += (char)((c<10)?('0'+c):(cBase+c-10));
+                f -= (int)f;
+            }
+            if( iScale >= j )
+            {
+                for( int k = j; k < iScale; k++ )
+                    fTmp += '0';
+                fTmp += ".0";
+            }
+
+            writeAligned( fTmp );
+            usedFormat();
+        }
+        
+        template<typename type>
+        void iparse( type &i, const Bu::String &sBuf )
+        {
+            if( !sBuf.isSet() )
+                return;
+            if( sBuf[0] != '+' && sBuf[0] != '-' &&
+                (sBuf[0] < '0' && sBuf[0] > '9') )
+                return;
+            int j = 1;
+            int iMax = sBuf.getSize();
+            for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
+            i = 0;
+            type iPos = 1;
+            for(j--; j >= 0; j-- )
+            {
+                if( sBuf[j] == '+' || sBuf[j] == '-' )
+                    continue;
+                i += (sBuf[j]-'0')*iPos;
+                iPos *= fLast.uRadix;
+            }
+            if( sBuf[0] == '-' )
+                i = -i;
+
+            usedFormat();
+        }
+        
+        template<typename type>
+        void uparse( type &i, const Bu::String &sBuf )
+        {
+            if( !sBuf.isSet() )
+                return;
+            if( sBuf[0] != '+' &&
+                (sBuf[0] < '0' && sBuf[0] > '9') )
+                return;
+            int j = 1;
+            int iMax = sBuf.getSize();
+            for(; j < iMax && (sBuf[j] >= '0' && sBuf[j] <= '9'); j++ ) { }
+            i = 0;
+            type iPos = 1;
+            for(j--; j >= 0; j-- )
+            {
+                if( sBuf[j] == '+' )
+                    continue;
+                i += (sBuf[j]-'0')*iPos;
+                iPos *= fLast.uRadix;
+            }
+
+            usedFormat();
+        }
+        
+        template<typename type>
+        void fparse( type &f, const Bu::String &sBuf )
+        {
+            double fIn;
+            sscanf( sBuf.getStr(), "%lf", &fIn );
+            f = fIn;
+            usedFormat();
+        }
+
+        enum Special
+        {
+            nl,
+            flush
+        };
+
+        void doFlush();
+
+        Stream &getStream() { return rStream; }
+        operator Stream&() { return rStream; }
+
+    private:
+        Stream &rStream;
+        Fmt fLast;
+        bool bTempFmt;
+        uint8_t uIndent;
+        char cIndent;
+    };
+
+    Formatter &operator<<( Formatter &f, const Fmt &fmt );
+    Formatter &operator<<( Formatter &f, Formatter::Special s );
+    Formatter &operator<<( Formatter &f, const char *sStr );
+    Formatter &operator<<( Formatter &f, char *sStr );
+    Formatter &operator<<( Formatter &f, const Bu::String &sStr );
+    Formatter &operator<<( Formatter &f, signed char c );
+    Formatter &operator<<( Formatter &f, char c );
+    Formatter &operator<<( Formatter &f, unsigned char c );
+    Formatter &operator<<( Formatter &f, signed short i );
+    Formatter &operator<<( Formatter &f, unsigned short i );
+    Formatter &operator<<( Formatter &f, signed int i );
+    Formatter &operator<<( Formatter &f, unsigned int i );
+    Formatter &operator<<( Formatter &f, signed long i );
+    Formatter &operator<<( Formatter &f, unsigned long i );
+    Formatter &operator<<( Formatter &f, signed long long i );
+    Formatter &operator<<( Formatter &f, unsigned long long i );
+    Formatter &operator<<( Formatter &f, float flt );
+    Formatter &operator<<( Formatter &f, double flt );
+    Formatter &operator<<( Formatter &f, long double flt );
+    Formatter &operator<<( Formatter &f, bool b );
+
+    Formatter &operator>>( Formatter &f, Bu::String &sStr );
+    Formatter &operator>>( Formatter &f, signed char &c );
+    Formatter &operator>>( Formatter &f, char &c );
+    Formatter &operator>>( Formatter &f, unsigned char &c );
+    Formatter &operator>>( Formatter &f, signed short &i );
+    Formatter &operator>>( Formatter &f, unsigned short &i );
+    Formatter &operator>>( Formatter &f, signed int &i );
+    Formatter &operator>>( Formatter &f, unsigned int &i );
+    Formatter &operator>>( Formatter &f, signed long &i );
+    Formatter &operator>>( Formatter &f, unsigned long &i );
+    Formatter &operator>>( Formatter &f, signed long long &i );
+    Formatter &operator>>( Formatter &f, unsigned long long &i );
+    Formatter &operator>>( Formatter &f, float &flt );
+    Formatter &operator>>( Formatter &f, double &flt );
+    Formatter &operator>>( Formatter &f, long double &flt );
+    Formatter &operator>>( Formatter &f, bool &b );
+
+    template<typename type>
+    Formatter &operator<<( Formatter &f, const type *p )
+    {
+        return f << "0x" << Fmt::hex(sizeof(ptrdiff_t)*2) << (ptrdiff_t)(p);
+    }
 };
 
 #endif
diff --git a/src/stable/formula.cpp b/src/stable/formula.cpp
index 6bc2c58..c5ba1ae 100644
--- a/src/stable/formula.cpp
+++ b/src/stable/formula.cpp
@@ -9,6 +9,6 @@
 
 namespace Bu
 {
-        subExceptionDef( FormulaException );
+    subExceptionDef( FormulaException );
 }
 
diff --git a/src/stable/formula.h b/src/stable/formula.h
index 36a0398..b12afd6 100644
--- a/src/stable/formula.h
+++ b/src/stable/formula.h
@@ -21,410 +21,410 @@
 
 namespace Bu
 {
-        subExceptionDecl( FormulaException );
-        /**
-         * Implements a very simple formula parser that allows use of variables and
-         * custom functions.  This is based on a simple calculator-type parser that
-         * executes as it processes, accounting for operator precedence and
-         * grouping.
-         *
-         * prec = precision, a type to use for all math (except binary ops)
-         * bin = binary type, a type to hard cast all data to for binary ops
-         */
-        template<typename prec, typename bin=uint32_t>
-        class Formula
-        {
-        public:
-                class Func
-                {
-                public:
-                        virtual prec operator()( prec )=0;
-                };
-
-                typedef Hash<Bu::String, prec> varHash;
-                typedef Hash<Bu::String, Func *> funcHash;
-
-                Formula()
-                {
-                }
-
-                virtual ~Formula()
-                {
-                        for( typename funcHash::iterator i = hFunc.begin();
-                                 i != hFunc.end(); i++ )
-                        {
-                                delete (*i);
-                        }
-                }
-
-                prec run( const Bu::String &sFormulaSrc )
-                {
-                        if( sFormulaSrc.isEmpty() )
-                                throw FormulaException("Empty formula, nothing to do.");
-                        try
-                        {
-                                const char *sFormula = sFormulaSrc.getStr();
-                                for(;;)
-                                {
-                                        uint8_t tNum = nextToken( &sFormula );
-                                        if( tNum == symSubtract )
-                                        {
-                                                sOper.push( symNegate );
-                                                continue;
-                                        }
-                                        else if( tNum == symNot )
-                                        {
-                                                sOper.push( symNot );
-                                                continue;
-                                        }
-                                        else if( tNum == symOpenParen )
-                                        {
-                                                sOper.push( tNum );
-                                                continue;
-                                        }
-                                        else if( tNum == symFunction )
-                                        {
-                                                sOper.push( symFunction );
-                                                continue;
-                                        }
-                                        else if( tNum == symEOS )
-                                        {
-                                                throw Bu::FormulaException(
-                                                        "Cannot end with an operator.");
-                                        }
-
-                        oppart: uint8_t tOpr = nextToken( &sFormula );
-                                        if( tOpr == symEOS )
-                                        {
-                                                reduce();
-                                                prec ret = sValue.top();
-                                                sValue.clear();
-                                                sFunc.clear();
-                                                sOper.clear();
-                                                return ret;
-                                        }
-                                        if( !sOper.isEmpty() && getPrec( sOper.top() ) >
-                                                getPrec( tOpr ) )
-                                        {
-                                                reduce();
-                                        }
-                                        if( tOpr != symCloseParen )
-                                        {
-                                                sOper.push( tOpr );
-                                        }
-                                        else
-                                        {
-                                                reduce( true );
-                                                goto oppart;
-                                        }
-                                }
-                        }
-                        catch( ... )
-                        {
-                                sValue.clear();
-                                sFunc.clear();
-                                sOper.clear();
-                                throw;
-                        }
-                }
-
-                varHash hVars;
-                funcHash hFunc;
-
-        private:
-                enum
-                {
-                        symEOS,
-                        symAdd,
-                        symSubtract,
-                        symMultiply,
-                        symDivide,
-                        symOpenParen,
-                        symCloseParen,
-                        symNumber,
-                        symVariable,
-                        symFunction,
-                        symExponent,
-                        symNegate,
-                        symModulus,
-
-                        symAnd,
-                        symOr,
-                        symXor,
-                        symNot
-                };
-
-                typedef uint8_t symType;
-
-                Bu::Stack<symType> sOper;
-                Bu::Stack<prec> sValue;
-                Bu::Stack<Bu::String> sFunc;
-
-        private:
-                symType getPrec( symType nOper )
-                {
-                        switch( nOper )
-                        {
-                                case symNumber:
-                                case symVariable:
-                                case symOpenParen:
-                                case symCloseParen:
-                                        return 0;
-
-                                case symAdd:
-                                case symSubtract:
-                                        return 1;
-
-                                case symMultiply:
-                                case symDivide:
-                                case symModulus:
-                                        return 2;
-
-                                case symAnd:
-                                case symOr:
-                                case symXor:
-                                        return 2;
-
-                                case symExponent:
-                                case symNot:
-                                case symNegate:
-                                case symFunction:
-                                        return 3;
-
-                                default:
-                                        return 0;
-                        }
-                }
-
-                symType nextToken( const char **sBuf )
-                {
-                        for(;;)
-                        {
-                                char cbuf = **sBuf;
-                                ++(*sBuf);
-                                switch( cbuf )
-                                {
-                                        case '+':
-                                                return symAdd;
-
-                                        case '-':
-                                                return symSubtract;
-
-                                        case '*':
-                                                return symMultiply;
-
-                                        case '/':
-                                                return symDivide;
-
-                                        case '^':
-                                                return symExponent;
-
-                                        case '%':
-                                                return symModulus;
-
-                                        case '(':
-                                                return symOpenParen;
-
-                                        case ')':
-                                                return symCloseParen;
-
-                                        case '|':
-                                                return symOr;
-
-                                        case '&':
-                                                return symAnd;
-
-                                        case '#':
-                                                return symXor;
-
-                                        case '~':
-                                                return symNot;
-
-                                        case ' ':
-                                        case '\t':
-                                        case '\n':
-                                        case '\r':
-                                                break;
-
-                                        case '\0':
-                                                return symEOS;
-
-                                        default:
-                                                if( cbuf == '.' || (cbuf >= '0' && cbuf <= '9') )
-                                                {
-                                                        char num[50]={cbuf};
-                                                        int nPos = 1;
-                                                        bool bDot = false;
-
-                                                        for(;;)
-                                                        {
-                                                                cbuf = **sBuf;
-                                                                if( cbuf == '.' )
-                                                                {
-                                                                        if( bDot == false )
-                                                                                bDot = true;
-                                                                        else
-                                                                                throw FormulaException(
-                                                                                        "Numbers cannot have more than one "
-                                                                                        ". in them."
-                                                                                        );
-                                                                }
-                                                                if( cbuf == '.' ||
-                                                                        (cbuf >= '0' && cbuf <= '9') )
-                                                                {
-                                                                        num[nPos++] = cbuf;
-                                                                }
-                                                                else
-                                                                {
-                                                                        num[nPos] = '\0';
-                                                                        sValue.push(
-                                                                                static_cast<prec>(
-                                                                                        strtod( num, NULL )
-                                                                                        )
-                                                                                );
-                                                                        return symNumber;
-                                                                }
-                                                                ++(*sBuf);
-                                                        }
-                                                }
-                                                else if( (cbuf >= 'a' && cbuf <= 'z') || 
-                                                                 (cbuf >= 'A' && cbuf <= 'Z') ||
-                                                                 (cbuf == '_') )
-                                                {
-                                                        char tok[50]={cbuf};
-                                                        int nPos = 1;
-
-                                                        for(;;)
-                                                        {
-                                                                cbuf = **sBuf;
-                                                                if( (cbuf >= 'a' && cbuf <= 'z') || 
-                                                                        (cbuf >= 'A' && cbuf <= 'Z') ||
-                                                                        (cbuf >= '0' && cbuf <= '9') ||
-                                                                        cbuf == '_' || cbuf == '.' || cbuf == ':' )
-                                                                {
-                                                                        tok[nPos++] = cbuf;
-                                                                }
-                                                                else
-                                                                {
-                                                                        tok[nPos] = '\0';
-                                                                        if( hVars.has( tok ) )
-                                                                        {
-                                                                                sValue.push( hVars[tok] );
-                                                                                return symNumber;
-                                                                        }
-                                                                        else if( hFunc.has( tok ) )
-                                                                        {
-                                                                                sFunc.push( tok );
-                                                                                return symFunction;
-                                                                        }
-                                                                        else
-                                                                        {
-                                                                                throw FormulaException(
-                                                                                        "No variable or function named "
-                                                                                        "\"%s\" exists.",
-                                                                                        tok
-                                                                                        );
-                                                                        }
-                                                                }
-                                                                ++(*sBuf);
-                                                        }
-                                                }
-                                                break;
-                                }
-                        }
-                }
-
-                void reduce( bool bCloseParen = false )
-                {
-                        while( !sOper.isEmpty() )
-                        {
-                                uint8_t nOpr = sOper.top();
-                                if( nOpr == symOpenParen )
-                                {
-                                        if( bCloseParen == true )
-                                                sOper.pop();
-                                        return;
-                                }
-                                sOper.pop();
-
-                                prec dTop = sValue.top();
-                                sValue.pop();
-
-                                switch( nOpr )
-                                {
-                                        case symAdd:
-                                                sValue.top() += dTop;
-                                                break;
-
-                                        case symSubtract:
-                                                sValue.top() -= dTop;
-                                                break;
-
-                                        case symMultiply:
-                                                sValue.top() *= dTop;
-                                                break;
-
-                                        case symDivide:
-                                                sValue.top() /= dTop;
-                                                break;
-
-                                        case symExponent:
-                                                sValue.top() = static_cast<prec>(
-                                                                pow( sValue.top(), dTop )
-                                                        );
-                                                break;
-
-                                        case symModulus:
-                                                sValue.top() = static_cast<prec>(
-                                                                fmod( sValue.top(), dTop )
-                                                        );
-                                                break;
-
-                                        case symOr:
-                                                sValue.top() = static_cast<prec>(
-                                                                static_cast<bin>(sValue.top()) |
-                                                                static_cast<bin>(dTop)
-                                                        );
-                                                break;
-                                        
-                                        case symAnd:
-                                                sValue.top() = static_cast<prec>(
-                                                                static_cast<bin>(sValue.top()) &
-                                                                static_cast<bin>(dTop)
-                                                        );
-                                                break;
-                                        
-                                        case symXor:
-                                                sValue.top() = static_cast<prec>(
-                                                                static_cast<bin>(sValue.top()) ^
-                                                                static_cast<bin>(dTop)
-                                                        );
-                                                break;
-
-                                        case symFunction:
-                                                sValue.push( (*hFunc.get( sFunc.pop() ))( dTop ) );
-                                                break;
-
-                                        case symNegate:
-                                                sValue.push( -dTop );
-                                                break;
-
-                                        case symNot:
-                                                sValue.push( static_cast<prec>(
-                                                                ~static_cast<bin>(dTop)
-                                                        ) );
-                                                break;
-                                }
-                        }
-
-                        if( bCloseParen == true )
-                        {
-                                throw FormulaException(
-                                        "Close-paren found without matching open-paren."
-                                        );
-                        }
-                }
-        };
+    subExceptionDecl( FormulaException );
+    /**
+     * Implements a very simple formula parser that allows use of variables and
+     * custom functions.  This is based on a simple calculator-type parser that
+     * executes as it processes, accounting for operator precedence and
+     * grouping.
+     *
+     * prec = precision, a type to use for all math (except binary ops)
+     * bin = binary type, a type to hard cast all data to for binary ops
+     */
+    template<typename prec, typename bin=uint32_t>
+    class Formula
+    {
+    public:
+        class Func
+        {
+        public:
+            virtual prec operator()( prec )=0;
+        };
+
+        typedef Hash<Bu::String, prec> varHash;
+        typedef Hash<Bu::String, Func *> funcHash;
+
+        Formula()
+        {
+        }
+
+        virtual ~Formula()
+        {
+            for( typename funcHash::iterator i = hFunc.begin();
+                 i != hFunc.end(); i++ )
+            {
+                delete (*i);
+            }
+        }
+
+        prec run( const Bu::String &sFormulaSrc )
+        {
+            if( sFormulaSrc.isEmpty() )
+                throw FormulaException("Empty formula, nothing to do.");
+            try
+            {
+                const char *sFormula = sFormulaSrc.getStr();
+                for(;;)
+                {
+                    uint8_t tNum = nextToken( &sFormula );
+                    if( tNum == symSubtract )
+                    {
+                        sOper.push( symNegate );
+                        continue;
+                    }
+                    else if( tNum == symNot )
+                    {
+                        sOper.push( symNot );
+                        continue;
+                    }
+                    else if( tNum == symOpenParen )
+                    {
+                        sOper.push( tNum );
+                        continue;
+                    }
+                    else if( tNum == symFunction )
+                    {
+                        sOper.push( symFunction );
+                        continue;
+                    }
+                    else if( tNum == symEOS )
+                    {
+                        throw Bu::FormulaException(
+                            "Cannot end with an operator.");
+                    }
+
+            oppart: uint8_t tOpr = nextToken( &sFormula );
+                    if( tOpr == symEOS )
+                    {
+                        reduce();
+                        prec ret = sValue.top();
+                        sValue.clear();
+                        sFunc.clear();
+                        sOper.clear();
+                        return ret;
+                    }
+                    if( !sOper.isEmpty() && getPrec( sOper.top() ) >
+                        getPrec( tOpr ) )
+                    {
+                        reduce();
+                    }
+                    if( tOpr != symCloseParen )
+                    {
+                        sOper.push( tOpr );
+                    }
+                    else
+                    {
+                        reduce( true );
+                        goto oppart;
+                    }
+                }
+            }
+            catch( ... )
+            {
+                sValue.clear();
+                sFunc.clear();
+                sOper.clear();
+                throw;
+            }
+        }
+
+        varHash hVars;
+        funcHash hFunc;
+
+    private:
+        enum
+        {
+            symEOS,
+            symAdd,
+            symSubtract,
+            symMultiply,
+            symDivide,
+            symOpenParen,
+            symCloseParen,
+            symNumber,
+            symVariable,
+            symFunction,
+            symExponent,
+            symNegate,
+            symModulus,
+
+            symAnd,
+            symOr,
+            symXor,
+            symNot
+        };
+
+        typedef uint8_t symType;
+
+        Bu::Stack<symType> sOper;
+        Bu::Stack<prec> sValue;
+        Bu::Stack<Bu::String> sFunc;
+
+    private:
+        symType getPrec( symType nOper )
+        {
+            switch( nOper )
+            {
+                case symNumber:
+                case symVariable:
+                case symOpenParen:
+                case symCloseParen:
+                    return 0;
+
+                case symAdd:
+                case symSubtract:
+                    return 1;
+
+                case symMultiply:
+                case symDivide:
+                case symModulus:
+                    return 2;
+
+                case symAnd:
+                case symOr:
+                case symXor:
+                    return 2;
+
+                case symExponent:
+                case symNot:
+                case symNegate:
+                case symFunction:
+                    return 3;
+
+                default:
+                    return 0;
+            }
+        }
+
+        symType nextToken( const char **sBuf )
+        {
+            for(;;)
+            {
+                char cbuf = **sBuf;
+                ++(*sBuf);
+                switch( cbuf )
+                {
+                    case '+':
+                        return symAdd;
+
+                    case '-':
+                        return symSubtract;
+
+                    case '*':
+                        return symMultiply;
+
+                    case '/':
+                        return symDivide;
+
+                    case '^':
+                        return symExponent;
+
+                    case '%':
+                        return symModulus;
+
+                    case '(':
+                        return symOpenParen;
+
+                    case ')':
+                        return symCloseParen;
+
+                    case '|':
+                        return symOr;
+
+                    case '&':
+                        return symAnd;
+
+                    case '#':
+                        return symXor;
+
+                    case '~':
+                        return symNot;
+
+                    case ' ':
+                    case '\t':
+                    case '\n':
+                    case '\r':
+                        break;
+
+                    case '\0':
+                        return symEOS;
+
+                    default:
+                        if( cbuf == '.' || (cbuf >= '0' && cbuf <= '9') )
+                        {
+                            char num[50]={cbuf};
+                            int nPos = 1;
+                            bool bDot = false;
+
+                            for(;;)
+                            {
+                                cbuf = **sBuf;
+                                if( cbuf == '.' )
+                                {
+                                    if( bDot == false )
+                                        bDot = true;
+                                    else
+                                        throw FormulaException(
+                                            "Numbers cannot have more than one "
+                                            ". in them."
+                                            );
+                                }
+                                if( cbuf == '.' ||
+                                    (cbuf >= '0' && cbuf <= '9') )
+                                {
+                                    num[nPos++] = cbuf;
+                                }
+                                else
+                                {
+                                    num[nPos] = '\0';
+                                    sValue.push(
+                                        static_cast<prec>(
+                                            strtod( num, NULL )
+                                            )
+                                        );
+                                    return symNumber;
+                                }
+                                ++(*sBuf);
+                            }
+                        }
+                        else if( (cbuf >= 'a' && cbuf <= 'z') || 
+                                 (cbuf >= 'A' && cbuf <= 'Z') ||
+                                 (cbuf == '_') )
+                        {
+                            char tok[50]={cbuf};
+                            int nPos = 1;
+
+                            for(;;)
+                            {
+                                cbuf = **sBuf;
+                                if( (cbuf >= 'a' && cbuf <= 'z') || 
+                                    (cbuf >= 'A' && cbuf <= 'Z') ||
+                                    (cbuf >= '0' && cbuf <= '9') ||
+                                    cbuf == '_' || cbuf == '.' || cbuf == ':' )
+                                {
+                                    tok[nPos++] = cbuf;
+                                }
+                                else
+                                {
+                                    tok[nPos] = '\0';
+                                    if( hVars.has( tok ) )
+                                    {
+                                        sValue.push( hVars[tok] );
+                                        return symNumber;
+                                    }
+                                    else if( hFunc.has( tok ) )
+                                    {
+                                        sFunc.push( tok );
+                                        return symFunction;
+                                    }
+                                    else
+                                    {
+                                        throw FormulaException(
+                                            "No variable or function named "
+                                            "\"%s\" exists.",
+                                            tok
+                                            );
+                                    }
+                                }
+                                ++(*sBuf);
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+
+        void reduce( bool bCloseParen = false )
+        {
+            while( !sOper.isEmpty() )
+            {
+                uint8_t nOpr = sOper.top();
+                if( nOpr == symOpenParen )
+                {
+                    if( bCloseParen == true )
+                        sOper.pop();
+                    return;
+                }
+                sOper.pop();
+
+                prec dTop = sValue.top();
+                sValue.pop();
+
+                switch( nOpr )
+                {
+                    case symAdd:
+                        sValue.top() += dTop;
+                        break;
+
+                    case symSubtract:
+                        sValue.top() -= dTop;
+                        break;
+
+                    case symMultiply:
+                        sValue.top() *= dTop;
+                        break;
+
+                    case symDivide:
+                        sValue.top() /= dTop;
+                        break;
+
+                    case symExponent:
+                        sValue.top() = static_cast<prec>(
+                                pow( sValue.top(), dTop )
+                            );
+                        break;
+
+                    case symModulus:
+                        sValue.top() = static_cast<prec>(
+                                fmod( sValue.top(), dTop )
+                            );
+                        break;
+
+                    case symOr:
+                        sValue.top() = static_cast<prec>(
+                                static_cast<bin>(sValue.top()) |
+                                static_cast<bin>(dTop)
+                            );
+                        break;
+                    
+                    case symAnd:
+                        sValue.top() = static_cast<prec>(
+                                static_cast<bin>(sValue.top()) &
+                                static_cast<bin>(dTop)
+                            );
+                        break;
+                    
+                    case symXor:
+                        sValue.top() = static_cast<prec>(
+                                static_cast<bin>(sValue.top()) ^
+                                static_cast<bin>(dTop)
+                            );
+                        break;
+
+                    case symFunction:
+                        sValue.push( (*hFunc.get( sFunc.pop() ))( dTop ) );
+                        break;
+
+                    case symNegate:
+                        sValue.push( -dTop );
+                        break;
+
+                    case symNot:
+                        sValue.push( static_cast<prec>(
+                                ~static_cast<bin>(dTop)
+                            ) );
+                        break;
+                }
+            }
+
+            if( bCloseParen == true )
+            {
+                throw FormulaException(
+                    "Close-paren found without matching open-paren."
+                    );
+            }
+        }
+    };
 }
 
 #endif
diff --git a/src/stable/hash.cpp b/src/stable/hash.cpp
index f44104b..85a13c7 100644
--- a/src/stable/hash.cpp
+++ b/src/stable/hash.cpp
@@ -12,58 +12,58 @@ namespace Bu { subExceptionDef( HashException ) }
 template<>
 uint32_t Bu::__calcHashCode<const char *>( const char * const &k )
 {
-        if (k == NULL)
-        {
-                return 0;
-        }
-        
-        unsigned long int nPos = 0;
-        for( const char *s = k; *s; s++ )
-        {
-                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
-        }
+    if (k == NULL)
+    {
+        return 0;
+    }
+    
+    unsigned long int nPos = 0;
+    for( const char *s = k; *s; s++ )
+    {
+        nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
+    }
 
-        return nPos;
+    return nPos;
 }
 
 template<> bool Bu::__cmpHashKeys<const char *>( const char * const &a, const char * const &b )
 {
-        if( a == b )
-                return true;
+    if( a == b )
+        return true;
 
-        for(int j=0; a[j] == b[j]; j++ )
-                if( a[j] == '\0' )
-                        return true;
+    for(int j=0; a[j] == b[j]; j++ )
+        if( a[j] == '\0' )
+            return true;
 
-        return false;
+    return false;
 }
 
 template<>
 uint32_t Bu::__calcHashCode<char *>( char * const &k )
 {
-        if (k == NULL)
-        {
-                return 0;
-        }
-        
-        unsigned long int nPos = 0;
-        for( const char *s = k; *s; s++ )
-        {
-                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
-        }
+    if (k == NULL)
+    {
+        return 0;
+    }
+    
+    unsigned long int nPos = 0;
+    for( const char *s = k; *s; s++ )
+    {
+        nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
+    }
 
-        return nPos;
+    return nPos;
 }
 
 template<> bool Bu::__cmpHashKeys<char *>( char * const &a, char * const &b )
 {
-        if( a == b )
-                return true;
+    if( a == b )
+        return true;
 
-        for(int j=0; a[j] == b[j]; j++ )
-                if( a[j] == '\0' )
-                        return true;
+    for(int j=0; a[j] == b[j]; j++ )
+        if( a[j] == '\0' )
+            return true;
 
-        return false;
+    return false;
 }
 
diff --git a/src/stable/hash.h b/src/stable/hash.h
index 86f189e..1574a1c 100644
--- a/src/stable/hash.h
+++ b/src/stable/hash.h
@@ -17,1311 +17,1311 @@
 
 namespace Bu
 {
-        subExceptionDecl( HashException )
-
-        enum eHashException
-        {
-                excodeNotFilled
-        };
-
-        template<typename T>
-        uint32_t __calcHashCode( const T &k );
-
-        template<typename T>
-        bool __cmpHashKeys( const T &a, const T &b );
-
-        /**
-         * Default functor used to compute the size of hash tables.  This version
-         * effectively doubles the size of the table when space is low, ensuring
-         * that you always wind up with an odd number for the table size.  A
-         * better but slower option is to always find the next prime number that's
-         * above double your current table size, but that has the potential to be
-         * slower.
-         */
-        struct __calcNextTSize_fast
-        {
-                uint32_t operator()( uint32_t nCapacity, uint32_t nFilled,
-                                uint32_t nDeleted ) const
-                {
-                        // This frist case will allow hashtables that are mostly deleted
-                        // items to reset to small allocations
-                        if( nFilled-nDeleted <= nCapacity/4 )
-                        {
-                                nCapacity = 11;
-                                while( nCapacity < nFilled*5/4 )
-                                        nCapacity = nCapacity*2+1;
-                                return nCapacity;
-                        }
-                        // This will hopefully prevent hash tables from growing needlessly
-                        if( nFilled-nDeleted <= nCapacity/2 )
-                        {
-                                if( nDeleted == 0 )
-                                        return nCapacity/4*5+1;  // Grow just a little
-                                else
-                                        return nCapacity;       // We're going to delete things
-                        }
-                        // Otherwise, just increase the capacity
-                        return nCapacity*2+1;
-                }
-        };
-
-        template<typename totype>
-        int bitsTo( int iCount )
-        {
-                return ( (iCount/(sizeof(totype)*8))
-                                + (iCount%(sizeof(totype)*8)>0 ? 1 : 0));
-        }
-
-        template<typename key, typename value, typename sizecalc, typename keyalloc,
-                typename valuealloc, typename challoc>
-        class Hash;
-
-        /** @cond DEVEL */
-        template<typename key, typename value, typename sizecalc, typename keyalloc,
-                typename valuealloc, typename challoc >
-        class HashCore
-        {
-        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-        friend class SharedCore<
-                Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>,
-                HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc>
-                >;
-        private:
-                HashCore() :
-                        nCapacity( 0 ),
-                        nFilled( 0 ),
-                        nDeleted( 0 ),
-                        bFilled( NULL ),
-                        bDeleted( NULL ),
-                        aKeys( NULL ),
-                        aValues( NULL ),
-                        aHashCodes( NULL )
-                {
-                }
-
-                virtual ~HashCore()
-                {
-                        clear();
-                }
-
-                void init()
-                {
-                        if( nCapacity > 0 )
-                                return;
-
-                        nCapacity = 11;
-                        nKeysSize = bitsTo<uint32_t>( nCapacity );
-                        bFilled = ca.allocate( nKeysSize );
-                        bDeleted = ca.allocate( nKeysSize );
-                        clearBits();
-
-                        aHashCodes = ca.allocate( nCapacity );
-                        aKeys = ka.allocate( nCapacity );
-                        aValues = va.allocate( nCapacity );
-                }
-
-                void clearBits()
-                {
-                        if( nCapacity == 0 )
-                                return;
-
-                        for( uint32_t j = 0; j < nKeysSize; j++ )
-                        {
-                                bFilled[j] = bDeleted[j] = 0;
-                        }
-                }
-
-                void fill( uint32_t loc, const key &k, const value &v, uint32_t hash )
-                {
-                        init();
-
-                        bFilled[loc/32] |= (1<<(loc%32));
-                        va.construct( &aValues[loc], v );
-                        ka.construct( &aKeys[loc], k );
-                        aHashCodes[loc] = hash;
-                        nFilled++;
-                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                        //      nFilled, nDeleted, nCapacity );
-                }
-
-                void _erase( uint32_t loc )
-                {
-                        if( nCapacity == 0 )
-                                return;
-
-                        bDeleted[loc/32] |= (1<<(loc%32));
-                        va.destroy( &aValues[loc] );
-                        ka.destroy( &aKeys[loc] );
-                        nDeleted++;
-                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                        //      nFilled, nDeleted, nCapacity );
-                }
-
-                key &getKeyAtPos( uint32_t nPos )
-                {
-                        if( nPos >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return aKeys[nPos];
-                }
-                
-                const key &getKeyAtPos( uint32_t nPos ) const
-                {
-                        if( nPos >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return aKeys[nPos];
-                }
-                
-                value &getValueAtPos( uint32_t nPos )
-                {
-                        if( nPos >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return aValues[nPos];
-                }
-                
-                const value &getValueAtPos( uint32_t nPos ) const
-                {
-                        if( nPos >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return aValues[nPos];
-                }
-
-                uint32_t getFirstPos( bool &bFinished ) const
-                {
-                        for( uint32_t j = 0; j < nCapacity; j++ )
-                        {
-                                if( isFilled( j ) )
-                                        if( !isDeleted( j ) )
-                                                return j;
-                        }
-
-                        bFinished = true;
-                        return 0;
-                }
-
-                uint32_t getNextPos( uint32_t nPos, bool &bFinished ) const
-                {
-                        for( uint32_t j = nPos+1; j < nCapacity; j++ )
-                        {
-                                if( isFilled( j ) )
-                                        if( !isDeleted( j ) )
-                                                return j;
-                        }
-
-                        bFinished = true;
-                        return 0;
-                }
-
-                uint32_t probe( uint32_t hash, const key &k, bool &bFill, bool rehash=true )
-                {
-                        init();
-
-                        uint32_t nCur = hash%nCapacity;
-
-                        // First we scan to see if the key is already there, abort if we
-                        // run out of probing room, or we find a non-filled entry
-                        int8_t j;
-                        for( j = 0;
-                                isFilled( nCur ) && j < 32;
-                                nCur = (nCur + (1<<j))%nCapacity, j++
-                                )
-                        {
-                                // Is this the same hash code we were looking for?
-                                if( hash == aHashCodes[nCur] )
-                                {
-                                        // Skip over deleted entries.  Deleted entries are also filled,
-                                        // so we only have to do this check here.
-                                        if( isDeleted( nCur ) )
-                                                continue;
-
-                                        // Is it really the same key? (for safety)
-                                        if( __cmpHashKeys( aKeys[nCur], k ) == true )
-                                        {
-                                                bFill = true;
-                                                return nCur;
-                                        }
-                                }
-                        }
-
-                        // This is our insurance, if the table is full, then go ahead and
-                        // rehash, then try again.
-                        if( (isFilled( nCur ) || j == 32) && rehash == true )
-                        {
-                                reHash( szCalc( nCapacity, nFilled, nDeleted ) );
-
-                                // This is potentially dangerous, and could cause an infinite loop.
-                                // Be careful writing probe, eh?
-                                return probe( hash, k, bFill );
-                        }
-
-                        bFill = false;
-                        return nCur;
-                }
-                
-                uint32_t probe( uint32_t hash, key k, bool &bFill ) const
-                {
-                        if( nCapacity == 0 )
-                                throw Bu::ExceptionBase("Probe in empty hash table.");
-
-                        uint32_t nCur = hash%nCapacity;
-
-                        // First we scan to see if the key is already there, abort if we
-                        // run out of probing room, or we find a non-filled entry
-                        for( int8_t j = 0;
-                                isFilled( nCur ) && j < 32;
-                                nCur = (nCur + (1<<j))%nCapacity, j++
-                                )
-                        {
-                                // Is this the same hash code we were looking for?
-                                if( hash == aHashCodes[nCur] )
-                                {
-                                        // Skip over deleted entries.  Deleted entries are also filled,
-                                        // so we only have to do this check here.
-                                        if( isDeleted( nCur ) )
-                                                continue;
-
-                                        // Is it really the same key? (for safety)
-                                        if( __cmpHashKeys( aKeys[nCur], k ) == true )
-                                        {
-                                                bFill = true;
-                                                return nCur;
-                                        }
-                                }
-                        }
-
-                        bFill = false;
-                        return nCur;
-                }
-                
-                void insert( const key &k, const value &v )
-                {
-                        uint32_t hash = __calcHashCode( k );
-                        bool bFill;
-                        uint32_t nPos = probe( hash, k, bFill );
-
-                        if( bFill )
-                        {
-                                va.destroy( &aValues[nPos] );
-                                va.construct( &aValues[nPos], v );
-                        }
-                        else
-                        {
-                                fill( nPos, k, v, hash );
-                        }
-                }
-
-                void reHash( uint32_t nNewSize )
-                {
-                        //printf("--rehash: %d --> %d (%d, %d)\n", nCapacity, nNewSize, nFilled, nDeleted );
-                        //printf("---REHASH---");
-                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                        //      nFilled, nDeleted, nCapacity );
-                        
-                        // Save all the old data
-                        uint32_t nOldCapacity = nCapacity;
-                        uint32_t *bOldFilled = bFilled;
-                        uint32_t *aOldHashCodes = aHashCodes;
-                        uint32_t nOldKeysSize = nKeysSize;
-                        uint32_t *bOldDeleted = bDeleted;
-                        value *aOldValues = aValues;
-                        key *aOldKeys = aKeys;
-                        
-                        // Calculate new sizes
-                        nCapacity = nNewSize;
-                        nKeysSize = bitsTo<uint32_t>( nCapacity );
-                
-                        // Allocate new memory + prep
-                        bFilled = ca.allocate( nKeysSize );
-                        bDeleted = ca.allocate( nKeysSize );
-                        clearBits();
-
-                        aHashCodes = ca.allocate( nCapacity );
-                        aKeys = ka.allocate( nCapacity );
-                        aValues = va.allocate( nCapacity );
-
-                        nDeleted = nFilled = 0;
-
-                        // Re-insert all of the old data (except deleted items)
-                        for( uint32_t j = 0; j < nOldCapacity; j++ )
-                        {
-                                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
-                                        (bOldDeleted[j/32]&(1<<(j%32)))==0 )
-                                {
-                                        insert( aOldKeys[j], aOldValues[j] );
-                                }
-                        }
-
-                        // Delete all of the old data
-                        for( uint32_t j = 0; j < nOldCapacity; j++ )
-                        {
-                                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
-                                        (bOldDeleted[j/32]&(1<<(j%32)))==0 )
-                                {
-                                        va.destroy( &aOldValues[j] );
-                                        ka.destroy( &aOldKeys[j] );
-                                }
-                        }
-                        va.deallocate( aOldValues, nOldCapacity );
-                        ka.deallocate( aOldKeys, nOldCapacity );
-                        ca.deallocate( bOldFilled, nOldKeysSize );
-                        ca.deallocate( bOldDeleted, nOldKeysSize );
-                        ca.deallocate( aOldHashCodes, nOldCapacity );
-                }
-
-                bool isFilled( uint32_t loc ) const
-                {
-                        if( loc >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return (bFilled[loc/32]&(1<<(loc%32)))!=0;
-                }
-
-                bool isDeleted( uint32_t loc ) const
-                {
-                        if( loc >= nCapacity )
-                                throw HashException("Referenced position invalid.");
-                        return (bDeleted[loc/32]&(1<<(loc%32)))!=0;
-                }
-
-                void clear()
-                {
-                        for( uint32_t j = 0; j < nCapacity; j++ )
-                        {
-                                if( isFilled( j ) )
-                                        if( !isDeleted( j ) )
-                                        {
-                                                va.destroy( &aValues[j] );
-                                                ka.destroy( &aKeys[j] );
-                                        }
-                        }
-                        va.deallocate( aValues, nCapacity );
-                        ka.deallocate( aKeys, nCapacity );
-                        ca.deallocate( bFilled, nKeysSize );
-                        ca.deallocate( bDeleted, nKeysSize );
-                        ca.deallocate( aHashCodes, nCapacity );
-                        
-                        bFilled = NULL;
-                        bDeleted = NULL;
-                        aKeys = NULL;
-                        aValues = NULL;
-                        aHashCodes = NULL;
-                        
-                        nCapacity = 0;
-                        nFilled = 0;
-                        nDeleted = 0;
-                }
-
-                uint32_t nCapacity;
-                uint32_t nFilled;
-                uint32_t nDeleted;
-                uint32_t *bFilled;
-                uint32_t *bDeleted;
-                uint32_t nKeysSize;
-                key *aKeys;
-                value *aValues;
-                uint32_t *aHashCodes;
-                valuealloc va;
-                keyalloc ka;
-                challoc ca;
-                sizecalc szCalc;
-        };
-        /** @endcond */
-
-        /**
-         * Libbu++ Template Hash Table.  This is your average hash table, that uses
-         * template functions in order to do fast, efficient, generalized hashing.
-         * It's pretty easy to use, and works well with all other libbu++ types so
-         * far.
-         *
-         * In order to use it, I recommend the following for all basic usage:
-         *@code
-         // Define a Hash typedef with strings as keys and ints as values.
-         typedef Bu::Hash<Bu::String, int> StrIntHash;
-
-         // Create one
-         StrIntHash hInts;
-
-         // Insert some integers
-         hInts["one"] = 1;
-         hInts["forty-two"] = 42;
-         hInts.insert("forty two", 42 );
-
-         // Get values out of the hash, the last two options are the most explicit,
-         // and must be used if the hash's value type does not match what you're
-         // comparing to exactly.
-         if( hInts["one"] == 1 ) doSomething();
-         if( hInts["forty-two"].value() == 42 ) doSomething();
-         if( hInts.get("forty two") == 42 ) doSomething();
-
-         // Iterate through the Hash
-         for( StrIntHash::iterator i = hInts.begin(); i != hInts.end(); i++ )
-         {
-                // i.getValue() works too
-                print("'%s' = %d\n", i.getKey().getStr(), (*i) );
-         }
-                                                                                                        
-         @endcode
-         *@param key (typename) The datatype of the hashtable keys
-         *@param value (typename) The datatype of the hashtable data
-         *@param sizecalc (typename) Functor to compute new table size on rehash
-         *@param keyalloc (typename) Memory allocator for hashtable keys
-         *@param valuealloc (typename) Memory allocator for hashtable values
-         *@param challoc (typename) Byte allocator for bitflags
-         *@ingroup Containers
-         */
-        template<typename key, typename value,
-                typename sizecalc = __calcNextTSize_fast,
-                typename keyalloc = std::allocator<key>,
-                typename valuealloc = std::allocator<value>,
-                typename challoc = std::allocator<uint32_t>
-                >
-        class Hash : public SharedCore<
-                                 Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>,
-                                 HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc>
-                                 >
-        {
-        private:
-                typedef class HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc> Core;
-                typedef class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> MyType;
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_resetCore;
-                using SharedCore<MyType, Core>::_allocateCore;
-        
-        public:
-                Hash()
-                {
-                }
-
-                Hash( const MyType &src ) :
-                        SharedCore<MyType, Core >( src )
-                {
-                }
-
-                virtual ~Hash()
-                {
-                }
-
-                /**
-                 * Get the current hash table capacity. (Changes at re-hash)
-                 *@returns (uint32_t) The current capacity.
-                 */
-                uint32_t getCapacity() const
-                {
-                        return core->nCapacity;
-                }
-
-                /**
-                 * Get the number of hash locations spoken for. (Including 
-                 * not-yet-cleaned-up deleted items.)
-                 *@returns (uint32_t) The current fill state.
-                 */
-                uint32_t getFill() const
-                {
-                        return core->nFilled;
-                }
-
-                /**
-                 * Get the number of items stored in the hash table.
-                 *@returns (uint32_t) The number of items stored in the hash table.
-                 */
-                uint32_t getSize() const
-                {
-                        return core->nFilled-core->nDeleted;
-                }
-
-                bool isEmpty() const
-                {
-                        return (core->nFilled-core->nDeleted) == 0;
-                }
-
-                /**
-                 * Get the number of items which have been deleted, but not yet
-                 * cleaned up.
-                 *@returns (uint32_t) The number of deleted items.
-                 */
-                uint32_t getDeleted() const
-                {
-                        return core->nDeleted;
-                }
-
-                struct HashProxy
-                {
-                friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-                private:
-                        HashProxy( MyType &h, const key *k, uint32_t nPos, uint32_t hash ) :
-                                hsh( h ),
-                                pKey( k ),
-                                nPos( nPos ),
-                                hash( hash ),
-                                bFilled( false )
-                        {
-                        }
-
-                        HashProxy( MyType &h, uint32_t nPos, value *pValue ) :
-                                hsh( h ),
-                                nPos( nPos ),
-                                pValue( pValue ),
-                                bFilled( true )
-                        {
-                        }
-
-                        MyType &hsh;
-                        const key *pKey;
-                        uint32_t nPos;
-                        value *pValue;
-                        uint32_t hash;
-                        bool bFilled;
-
-                public:
-                        /**
-                         * Cast operator for HashProxy.
-                         *@returns (value_type &) The value the HashProxy is pointing to.
-                         */
-                        operator value &()
-                        {
-                                if( bFilled == false )
-                                        throw HashException(
-                                                        excodeNotFilled,
-                                                        "No data associated with that key."
-                                                        );
-                                return *pValue;
-                        }
-
-                        /**
-                         * Direct function for retrieving a value out of the HashProxy.
-                         *@returns (value_type &) The value pointed to by this HashProxy.
-                         */
-                        value &getValue()
-                        {
-                                if( bFilled == false )
-                                        throw HashException(
-                                                        excodeNotFilled,
-                                                        "No data associated with that key."
-                                                        );
-                                return *pValue;
-                        }
-
-                        /**
-                         * Whether this HashProxy points to something real or not.
-                         */
-                        bool isFilled()
-                        {
-                                return bFilled;
-                        }
-
-                        /**
-                         * Erase the data pointed to by this HashProxy.
-                         */
-                        void erase()
-                        {
-                                if( bFilled )
-                                {
-                                        hsh.core->_erase( nPos );
-                                }
-                        }
-
-                        /**
-                         * Assign data to this point in the hash table.
-                         *@param nval (value_type) the data to assign.
-                         */
-                        value operator=( value nval )
-                        {
-                                if( bFilled )
-                                {
-                                        hsh.core->va.destroy( &hsh.core->aValues[nPos] );
-                                        hsh.core->va.construct( &hsh.core->aValues[nPos], nval );
-                                }
-                                else
-                                {
-                                        hsh.core->fill( nPos, *pKey, nval, hash ); 
-                                }
-
-                                return nval;
-                        }
-
-                        /**
-                         * Pointer extraction operator. Access to members of data pointed to
-                         *              by HashProxy.
-                         *@returns (value_type *)
-                         */
-                        value *operator->()
-                        {
-                                if( bFilled == false )
-                                        throw HashException(
-                                                        excodeNotFilled,
-                                                        "No data associated with that key."
-                                                        );
-                                return pValue;
-                        }
-                };
-
-                /**
-                 * Hash table index operator
-                 *@param k (key_type) Key of data to be retrieved.
-                 *@returns (HashProxy) Proxy pointing to the data.
-                 */
-                HashProxy operator[]( const key &k )
-                {
-                        _hardCopy();
-
-                        uint32_t hash = __calcHashCode( k );
-                        bool bFill;
-                        uint32_t nPos = core->probe( hash, k, bFill );
-
-                        if( bFill )
-                        {
-                                return HashProxy( *this, nPos, &core->aValues[nPos] );
-                        }
-                        else
-                        {
-                                return HashProxy( *this, &k, nPos, hash );
-                        }
-                }
-
-                /**
-                 * Insert a value (v) under key (k) into the hash table
-                 *@param k (key_type) Key to list the value under.
-                 *@param v (value_type) Value to store in the hash table.
-                 */
-                void insert( const key &k, const value &v )
-                {
-                        _hardCopy();
-
-                        core->insert( k, v );
-                }
-
-                /**
-                 * Remove a value from the hash table.
-                 *@param k (key_type) The data under this key will be erased.
-                 */
-                void erase( const key &k )
-                {
-                        _hardCopy();
-
-                        uint32_t hash = __calcHashCode( k );
-                        bool bFill;
-                        uint32_t nPos = core->probe( hash, k, bFill );
-
-                        if( bFill )
-                        {
-                                core->_erase( nPos );
-                        }
-                }
-
-                struct iterator;
-
-                /**
-                 * Remove a value from the hash pointed to from an iterator.
-                 *@param i (iterator &) The data to be erased.
-                 */
-                void erase( struct iterator &i )
-                {
-                        if( this != i.hsh )
-                                throw HashException("This iterator didn't come from this Hash.");
-                        
-                        _hardCopy();
-
-                        if( core->isFilled( i.nPos ) && !core->isDeleted( i.nPos ) )
-                        {
-                                core->_erase( i.nPos );
-                        }
-                }
-
-                /**
-                 * Remove all data from the hash table.
-                 */
-                virtual void clear()
-                {
-                        _resetCore();
-                }
-
-                /**
-                 * Get an item of data from the hash table.
-                 *@param k (key_type) Key pointing to the data to be retrieved.
-                 *@returns (value_type &) The data pointed to by (k).
-                 */
-                value &get( const key &k )
-                {
-                        _hardCopy();
-
-                        uint32_t hash = __calcHashCode( k );
-                        bool bFill;
-                        uint32_t nPos = core->probe( hash, k, bFill, false );
-
-                        if( bFill )
-                        {
-                                return core->aValues[nPos];
-                        }
-                        else
-                        {
-                                throw HashException(
-                                                excodeNotFilled,
-                                                "No data associated with that key."
-                                                );
-                        }
-                }
-                
-                /**
-                 * Get a const item of data from the hash table.
-                 *@param k (key_type) Key pointing to the data to be retrieved.
-                 *@returns (const value_type &) A const version of the data pointed
-                 *              to by (k).
-                 */
-                const value &get( const key &k ) const
-                {
-                        uint32_t hash = __calcHashCode( k );
-                        bool bFill;
-                        uint32_t nPos = core->probe( hash, k, bFill );
-
-                        if( bFill )
-                        {
-                                return core->aValues[nPos];
-                        }
-                        else
-                        {
-                                throw HashException(
-                                                excodeNotFilled,
-                                                "No data associated with that key."
-                                                );
-                        }
-                }
-
-                /**
-                 * Does the hash table contain an item under key (k).
-                 *@param k (key_type) The key to check.
-                 *@returns (bool) Whether there was an item in the hash under key (k).
-                 */
-                bool has( const key &k ) const
-                {
-                        bool bFill;
-                        core->probe( __calcHashCode( k ), k, bFill );
-
-                        return bFill;
-                }
-
-                /**
-                 * Iteration structure for iterating through the hash.
-                 */
-                typedef struct iterator
-                {
-                        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-                private:
-                        iterator( MyType *hsh ) :
-                                hsh( hsh ),
-                                nPos( 0 ),
-                                bFinished( false )
-                        {
-                                nPos = hsh->core->getFirstPos( bFinished );
-                        }
-                        
-                        iterator( MyType *hsh, bool bDone ) :
-                                hsh( hsh ),
-                                nPos( 0 ),
-                                bFinished( bDone )
-                        {
-                        }
-
-                        MyType *hsh;
-                        uint32_t nPos;
-                        bool bFinished;
-
-                public:
-                        iterator( const iterator &i ) :
-                                hsh( i.hsh ),
-                                nPos( i.nPos ),
-                                bFinished( i.bFinished )
-                        {
-                        }
-
-                        iterator() :
-                                hsh( NULL ),
-                                nPos( NULL ),
-                                bFinished( true )
-                        {
-                        }
-
-                        bool isValid() const
-                        {
-                                return !bFinished;
-                        }
-
-                        operator bool() const
-                        {
-                                return !bFinished;
-                        }
-
-                        /**
-                         * Iterator incrementation operator. Move the iterator forward.
-                         */
-                        iterator operator++( int )
-                        {
-                                if( bFinished == false )
-                                        nPos = hsh->core->getNextPos( nPos, bFinished );
-
-                                return *this;
-                        }
-                        
-                        /**
-                         * Iterator incrementation operator. Move the iterator forward.
-                         */
-                        iterator operator++()
-                        {
-                                if( bFinished == false )
-                                        nPos = hsh->core->getNextPos( nPos, bFinished );
-
-                                return *this;
-                        }
-
-                        /**
-                         * Iterator equality comparison operator. Iterators the same?
-                         */
-                        bool operator==( const iterator &oth ) const
-                        {
-                                if( bFinished != oth.bFinished )
-                                        return false;
-                                if( bFinished == true )
-                                {
-                                        return true;
-                                }
-                                else
-                                {
-                                        if( oth.nPos == nPos )
-                                                return true;
-                                        return false;
-                                }
-                        }
-                        
-                        /**
-                         * Iterator not equality comparison operator. Not the same?
-                         */
-                        bool operator!=( const iterator &oth ) const
-                        {
-                                return !(*this == oth );
-                        }
-
-                        /**
-                         * Iterator assignment operator.
-                         */
-                        iterator operator=( const iterator &oth )
-                        {
-                                hsh = oth.hsh;
-                                nPos = oth.nPos;
-                                bFinished = oth.bFinished;
-                                return *this;
-                        }
-
-                        /**
-                         * Iterator dereference operator... err.. get the value
-                         *@returns (value_type &) The value behind this iterator.
-                         */
-                        value &operator *()
-                        {
-                                hsh->_hardCopy();
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-
-                        const value &operator *() const
-                        {
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-                        
-                        /**
-                         * Get the key behind this iterator.
-                         *@returns (key_type &) The key behind this iterator.
-                         */
-                        const key &getKey() const
-                        {
-                                return hsh->core->getKeyAtPos( nPos );
-                        }
-
-                        /**
-                         * Get the value behind this iterator.
-                         *@returns (value_type &) The value behind this iterator.
-                         */
-                        value &getValue()
-                        {
-                                hsh->_hardCopy();
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-
-                        /**
-                         * Get the value behind this iterator.
-                         *@returns (value_type &) The value behind this iterator.
-                         */
-                        const value &getValue() const
-                        {
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-                } iterator;
-                
-                /**
-                 * Iteration structure for iterating through the hash (const).
-                 */
-                typedef struct const_iterator
-                {
-                        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-                private:
-                        const_iterator( const MyType *hsh ) :
-                                hsh( hsh ),
-                                nPos( 0 ),
-                                bFinished( false )
-                        {
-                                nPos = hsh->core->getFirstPos( bFinished );
-                        }
-                        
-                        const_iterator( const MyType *hsh, bool bDone ) :
-                                hsh( hsh ),
-                                nPos( 0 ),
-                                bFinished( bDone )
-                        {
-                        }
-
-                        const MyType *hsh;
-                        uint32_t nPos;
-                        bool bFinished;
-
-                public:
-                        const_iterator() :
-                                hsh( NULL ),
-                                nPos( 0 ),
-                                bFinished( true )
-                        {
-                        }
-
-                        const_iterator( const const_iterator &src ) :
-                                hsh( src.hsh ),
-                                nPos( src.nPos ),
-                                bFinished( src.bFinished )
-                        {
-                        }
-
-                        const_iterator( const iterator &src ) :
-                                hsh( src.hsh ),
-                                nPos( src.nPos ),
-                                bFinished( src.bFinished )
-                        {
-                        }
-
-                        bool isValid() const
-                        {
-                                return !bFinished;
-                        }
-
-                        operator bool() const
-                        {
-                                return !bFinished;
-                        }
-
-                        /**
-                         * Iterator incrementation operator. Move the iterator forward.
-                         */
-                        const_iterator operator++( int )
-                        {
-                                if( bFinished == false )
-                                        nPos = hsh->core->getNextPos( nPos, bFinished );
-
-                                return *this;
-                        }
-                        
-                        /**
-                         * Iterator incrementation operator. Move the iterator forward.
-                         */
-                        const_iterator operator++()
-                        {
-                                if( bFinished == false )
-                                        nPos = hsh->core->getNextPos( nPos, bFinished );
-
-                                return *this;
-                        }
-
-                        /**
-                         * Iterator equality comparison operator. Iterators the same?
-                         */
-                        bool operator==( const const_iterator &oth ) const
-                        {
-                                if( bFinished != oth.bFinished )
-                                        return false;
-                                if( bFinished == true )
-                                {
-                                        return true;
-                                }
-                                else
-                                {
-                                        if( oth.nPos == nPos )
-                                                return true;
-                                        return false;
-                                }
-                        }
-                        
-                        /**
-                         * Iterator not equality comparison operator. Not the same?
-                         */
-                        bool operator!=( const const_iterator &oth ) const
-                        {
-                                return !(*this == oth );
-                        }
-
-                        /**
-                         * Iterator assignment operator.
-                         */
-                        const_iterator operator=( const const_iterator &oth )
-                        {
-                                hsh = oth.hsh;
-                                nPos = oth.nPos;
-                                bFinished = oth.bFinished;
-                                return *this;
-                        }
-
-                        /**
-                         * Iterator dereference operator... err.. get the value
-                         *@returns (value_type &) The value behind this iterator.
-                         */
-                        const value &operator *() const
-                        {
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-                        
-                        /**
-                         * Get the key behind this iterator.
-                         *@returns (key_type &) The key behind this iterator.
-                         */
-                        const key &getKey() const
-                        {
-                                return hsh->core->getKeyAtPos( nPos );
-                        }
-
-                        /**
-                         * Get the value behind this iterator.
-                         *@returns (value_type &) The value behind this iterator.
-                         */
-                        const value &getValue() const
-                        {
-                                return hsh->core->getValueAtPos( nPos );
-                        }
-                } const_iterator;
-
-                /**
-                 * Get an iterator pointing to the first item in the hash table.
-                 *@returns (iterator) An iterator pointing to the first item in the
-                 *              hash table.
-                 */
-                iterator begin()
-                {
-                        return iterator( this );
-                }
-                
-                const_iterator begin() const
-                {
-                        return const_iterator( this );
-                }
-                
-                /**
-                 * Get an iterator pointing to a point just past the last item in the
-                 *              hash table.
-                 *@returns (iterator) An iterator pointing to a point just past the
-                 *              last item in the hash table.
-                 */
-                iterator end()
-                {
-                        return iterator( this, true );
-                }
-                
-                const_iterator end() const
-                {
-                        return const_iterator( this, true );
-                }
-
-                /**
-                 * Get a list of all the keys in the hash table.
-                 *@returns (std::list<key_type>) The list of keys in the hash table.
-                 */
-                Bu::List<key> getKeys() const
-                {
-                        Bu::List<key> lKeys;
-
-                        for( uint32_t j = 0; j < core->nCapacity; j++ )
-                        {
-                                if( core->isFilled( j ) )
-                                {
-                                        if( !core->isDeleted( j ) )
-                                        {
-                                                lKeys.append( core->aKeys[j] );
-                                        }
-                                }
-                        }
-
-                        return lKeys;
-                }
-                
-                Bu::List<value> getValues() const
-                {
-                        Bu::List<value> lValues;
-
-                        for( uint32_t j = 0; j < core->nCapacity; j++ )
-                        {
-                                if( core->isFilled( j ) )
-                                {
-                                        if( !core->isDeleted( j ) )
-                                        {
-                                                lValues.append( core->aValues[j] );
-                                        }
-                                }
-                        }
-
-                        return lValues;
-                }
-
-                bool operator==( const MyType &rhs ) const
-                {
-                        if( this == &rhs )
-                                return true;
-                        if( core == rhs.core )
-                                return true;
-                        if( core == NULL || rhs.core == NULL )
-                                return false;
-                        if( getSize() != rhs.getSize() )
-                                return false;
-
-                        for( uint32_t j = 0; j < core->nCapacity; j++ )
-                        {
-                                if( core->isFilled( j ) )
-                                {
-                                        if( !core->isDeleted( j ) )
-                                        {
-                                                // Check to see if this key is in the other hash
-                                                if( rhs.has( core->aKeys[j] ) )
-                                                {
-                                                        if( !(core->aValues[j] == rhs.get( core->aKeys[j]) ) )
-                                                        {
-                                                                return false;
-                                                        }
-                                                }
-                                                else
-                                                {
-                                                        return false;
-                                                }
-                                        }
-                                }
-                        }
-
-                        return true;
-                }
-
-                bool operator!=( const MyType &rhs ) const
-                {
-                        return !(*this == rhs);
-                }
-
-                MyType &operator+=( const MyType &rhs )
-                {
-                        if( this == &rhs )
-                                return *this;
-                        if( core == rhs.core )
-                                return *this;
-                        if( core == NULL || rhs.core == NULL )
-                                return *this;
-
-                        for( const_iterator i = rhs.begin(); i; i++ )
-                                insert( i.getKey(), i.getValue() );
-
-                        return *this;
-                }
-
-        protected:
-                virtual Core *_copyCore( Core *src )
-                {
-                        Core *pRet = _allocateCore();
-
-                        pRet->nFilled = 0;
-                        pRet->nDeleted = 0;
-                        pRet->nCapacity = src->nCapacity;
-                        pRet->nKeysSize = bitsTo<uint32_t>( pRet->nCapacity );
-                        pRet->bFilled = pRet->ca.allocate( pRet->nKeysSize );
-                        pRet->bDeleted = pRet->ca.allocate( pRet->nKeysSize );
-                        pRet->clearBits();
-
-                        pRet->aHashCodes = pRet->ca.allocate( pRet->nCapacity );
-                        pRet->aKeys = pRet->ka.allocate( pRet->nCapacity );
-                        pRet->aValues = pRet->va.allocate( pRet->nCapacity );
-
-                        for( uint32_t j = 0; j < src->nCapacity; j++ )
-                        {
-                                if( src->isFilled( j ) && !src->isDeleted( j ) )
-                                {
-                                        pRet->insert( src->aKeys[j], src->aValues[j] );
-                                }
-                        }
-
-                        return pRet;
-                }
-        };
-        
-        template<typename T> uint32_t __calcHashCode( const T &k )
-        {
-                return static_cast<uint32_t>( k );
-        }
-
-        template<typename T> bool __cmpHashKeys( const T &a, const T &b )
-        {
-                return (a == b);
-        }
-
-        template<> uint32_t __calcHashCode<const char *>( const char * const &k );
-        template<> bool __cmpHashKeys<const char *>( const char * const &a, const char * const &b );
-
-        template<> uint32_t __calcHashCode<char *>( char * const &k );
-        template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b );
-
-        class Formatter;
-        Formatter &operator<<( Formatter &rOut, char *sStr );
-        Formatter &operator<<( Formatter &rOut, signed char c );
-        template<typename key, typename value>
-        Formatter &operator<<( Formatter &f, const Bu::Hash<key, value> &l )
-        {
-                f << '{';
-                for( typename Bu::Hash<key,value>::const_iterator i = l.begin(); i; i++ )
-                {
-                        if( i != l.begin() )
-                                f << ", ";
-                        f << i.getKey() << ": " << i.getValue();
-                }
-                f << '}';
-
-                return f;
-        }
-
-        template<typename key, typename value, typename a, typename b,
-                typename c, typename d>
-        ArchiveBase &operator<<( ArchiveBase &ar, const Hash<key,value,a,b,c,d> &h )
-        {
-                long iSize = h.getSize();
-                ar << iSize;
-                for( typename Hash<key,value,a,b,c,d>::const_iterator i = h.begin(); i != h.end(); i++ )
-                {
-                        ar << (i.getKey());
-                        ar << (i.getValue());
-                }
-
-                return ar;
-        }
-
-        template<typename key, typename value, typename a, typename b,
-                typename c, typename d>
-        ArchiveBase &operator>>( ArchiveBase &ar, Hash<key,value,a,b,c,d> &h )
-        {
-                h.clear();
-                long nSize;
-                ar >> nSize;
-
-                for( long j = 0; j < nSize; j++ )
-                {
-                        key k; value v;
-                        ar >> k >> v;
-                        h.insert( k, v );
-                }
-
-                return ar;
-        }
+    subExceptionDecl( HashException )
+
+    enum eHashException
+    {
+        excodeNotFilled
+    };
+
+    template<typename T>
+    uint32_t __calcHashCode( const T &k );
+
+    template<typename T>
+    bool __cmpHashKeys( const T &a, const T &b );
+
+    /**
+     * Default functor used to compute the size of hash tables.  This version
+     * effectively doubles the size of the table when space is low, ensuring
+     * that you always wind up with an odd number for the table size.  A
+     * better but slower option is to always find the next prime number that's
+     * above double your current table size, but that has the potential to be
+     * slower.
+     */
+    struct __calcNextTSize_fast
+    {
+        uint32_t operator()( uint32_t nCapacity, uint32_t nFilled,
+                uint32_t nDeleted ) const
+        {
+            // This frist case will allow hashtables that are mostly deleted
+            // items to reset to small allocations
+            if( nFilled-nDeleted <= nCapacity/4 )
+            {
+                nCapacity = 11;
+                while( nCapacity < nFilled*5/4 )
+                    nCapacity = nCapacity*2+1;
+                return nCapacity;
+            }
+            // This will hopefully prevent hash tables from growing needlessly
+            if( nFilled-nDeleted <= nCapacity/2 )
+            {
+                if( nDeleted == 0 )
+                    return nCapacity/4*5+1;  // Grow just a little
+                else
+                    return nCapacity;   // We're going to delete things
+            }
+            // Otherwise, just increase the capacity
+            return nCapacity*2+1;
+        }
+    };
+
+    template<typename totype>
+    int bitsTo( int iCount )
+    {
+        return ( (iCount/(sizeof(totype)*8))
+                + (iCount%(sizeof(totype)*8)>0 ? 1 : 0));
+    }
+
+    template<typename key, typename value, typename sizecalc, typename keyalloc,
+        typename valuealloc, typename challoc>
+    class Hash;
+
+    /** @cond DEVEL */
+    template<typename key, typename value, typename sizecalc, typename keyalloc,
+        typename valuealloc, typename challoc >
+    class HashCore
+    {
+    friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+    friend class SharedCore<
+        Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>,
+        HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc>
+        >;
+    private:
+        HashCore() :
+            nCapacity( 0 ),
+            nFilled( 0 ),
+            nDeleted( 0 ),
+            bFilled( NULL ),
+            bDeleted( NULL ),
+            aKeys( NULL ),
+            aValues( NULL ),
+            aHashCodes( NULL )
+        {
+        }
+
+        virtual ~HashCore()
+        {
+            clear();
+        }
+
+        void init()
+        {
+            if( nCapacity > 0 )
+                return;
+
+            nCapacity = 11;
+            nKeysSize = bitsTo<uint32_t>( nCapacity );
+            bFilled = ca.allocate( nKeysSize );
+            bDeleted = ca.allocate( nKeysSize );
+            clearBits();
+
+            aHashCodes = ca.allocate( nCapacity );
+            aKeys = ka.allocate( nCapacity );
+            aValues = va.allocate( nCapacity );
+        }
+
+        void clearBits()
+        {
+            if( nCapacity == 0 )
+                return;
+
+            for( uint32_t j = 0; j < nKeysSize; j++ )
+            {
+                bFilled[j] = bDeleted[j] = 0;
+            }
+        }
+
+        void fill( uint32_t loc, const key &k, const value &v, uint32_t hash )
+        {
+            init();
+
+            bFilled[loc/32] |= (1<<(loc%32));
+            va.construct( &aValues[loc], v );
+            ka.construct( &aKeys[loc], k );
+            aHashCodes[loc] = hash;
+            nFilled++;
+            //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
+            //  nFilled, nDeleted, nCapacity );
+        }
+
+        void _erase( uint32_t loc )
+        {
+            if( nCapacity == 0 )
+                return;
+
+            bDeleted[loc/32] |= (1<<(loc%32));
+            va.destroy( &aValues[loc] );
+            ka.destroy( &aKeys[loc] );
+            nDeleted++;
+            //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
+            //  nFilled, nDeleted, nCapacity );
+        }
+
+        key &getKeyAtPos( uint32_t nPos )
+        {
+            if( nPos >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return aKeys[nPos];
+        }
+        
+        const key &getKeyAtPos( uint32_t nPos ) const
+        {
+            if( nPos >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return aKeys[nPos];
+        }
+        
+        value &getValueAtPos( uint32_t nPos )
+        {
+            if( nPos >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return aValues[nPos];
+        }
+        
+        const value &getValueAtPos( uint32_t nPos ) const
+        {
+            if( nPos >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return aValues[nPos];
+        }
+
+        uint32_t getFirstPos( bool &bFinished ) const
+        {
+            for( uint32_t j = 0; j < nCapacity; j++ )
+            {
+                if( isFilled( j ) )
+                    if( !isDeleted( j ) )
+                        return j;
+            }
+
+            bFinished = true;
+            return 0;
+        }
+
+        uint32_t getNextPos( uint32_t nPos, bool &bFinished ) const
+        {
+            for( uint32_t j = nPos+1; j < nCapacity; j++ )
+            {
+                if( isFilled( j ) )
+                    if( !isDeleted( j ) )
+                        return j;
+            }
+
+            bFinished = true;
+            return 0;
+        }
+
+        uint32_t probe( uint32_t hash, const key &k, bool &bFill, bool rehash=true )
+        {
+            init();
+
+            uint32_t nCur = hash%nCapacity;
+
+            // First we scan to see if the key is already there, abort if we
+            // run out of probing room, or we find a non-filled entry
+            int8_t j;
+            for( j = 0;
+                isFilled( nCur ) && j < 32;
+                nCur = (nCur + (1<<j))%nCapacity, j++
+                )
+            {
+                // Is this the same hash code we were looking for?
+                if( hash == aHashCodes[nCur] )
+                {
+                    // Skip over deleted entries.  Deleted entries are also filled,
+                    // so we only have to do this check here.
+                    if( isDeleted( nCur ) )
+                        continue;
+
+                    // Is it really the same key? (for safety)
+                    if( __cmpHashKeys( aKeys[nCur], k ) == true )
+                    {
+                        bFill = true;
+                        return nCur;
+                    }
+                }
+            }
+
+            // This is our insurance, if the table is full, then go ahead and
+            // rehash, then try again.
+            if( (isFilled( nCur ) || j == 32) && rehash == true )
+            {
+                reHash( szCalc( nCapacity, nFilled, nDeleted ) );
+
+                // This is potentially dangerous, and could cause an infinite loop.
+                // Be careful writing probe, eh?
+                return probe( hash, k, bFill );
+            }
+
+            bFill = false;
+            return nCur;
+        }
+        
+        uint32_t probe( uint32_t hash, key k, bool &bFill ) const
+        {
+            if( nCapacity == 0 )
+                throw Bu::ExceptionBase("Probe in empty hash table.");
+
+            uint32_t nCur = hash%nCapacity;
+
+            // First we scan to see if the key is already there, abort if we
+            // run out of probing room, or we find a non-filled entry
+            for( int8_t j = 0;
+                isFilled( nCur ) && j < 32;
+                nCur = (nCur + (1<<j))%nCapacity, j++
+                )
+            {
+                // Is this the same hash code we were looking for?
+                if( hash == aHashCodes[nCur] )
+                {
+                    // Skip over deleted entries.  Deleted entries are also filled,
+                    // so we only have to do this check here.
+                    if( isDeleted( nCur ) )
+                        continue;
+
+                    // Is it really the same key? (for safety)
+                    if( __cmpHashKeys( aKeys[nCur], k ) == true )
+                    {
+                        bFill = true;
+                        return nCur;
+                    }
+                }
+            }
+
+            bFill = false;
+            return nCur;
+        }
+        
+        void insert( const key &k, const value &v )
+        {
+            uint32_t hash = __calcHashCode( k );
+            bool bFill;
+            uint32_t nPos = probe( hash, k, bFill );
+
+            if( bFill )
+            {
+                va.destroy( &aValues[nPos] );
+                va.construct( &aValues[nPos], v );
+            }
+            else
+            {
+                fill( nPos, k, v, hash );
+            }
+        }
+
+        void reHash( uint32_t nNewSize )
+        {
+            //printf("--rehash: %d --> %d (%d, %d)\n", nCapacity, nNewSize, nFilled, nDeleted );
+            //printf("---REHASH---");
+            //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
+            //  nFilled, nDeleted, nCapacity );
+            
+            // Save all the old data
+            uint32_t nOldCapacity = nCapacity;
+            uint32_t *bOldFilled = bFilled;
+            uint32_t *aOldHashCodes = aHashCodes;
+            uint32_t nOldKeysSize = nKeysSize;
+            uint32_t *bOldDeleted = bDeleted;
+            value *aOldValues = aValues;
+            key *aOldKeys = aKeys;
+            
+            // Calculate new sizes
+            nCapacity = nNewSize;
+            nKeysSize = bitsTo<uint32_t>( nCapacity );
+        
+            // Allocate new memory + prep
+            bFilled = ca.allocate( nKeysSize );
+            bDeleted = ca.allocate( nKeysSize );
+            clearBits();
+
+            aHashCodes = ca.allocate( nCapacity );
+            aKeys = ka.allocate( nCapacity );
+            aValues = va.allocate( nCapacity );
+
+            nDeleted = nFilled = 0;
+
+            // Re-insert all of the old data (except deleted items)
+            for( uint32_t j = 0; j < nOldCapacity; j++ )
+            {
+                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
+                    (bOldDeleted[j/32]&(1<<(j%32)))==0 )
+                {
+                    insert( aOldKeys[j], aOldValues[j] );
+                }
+            }
+
+            // Delete all of the old data
+            for( uint32_t j = 0; j < nOldCapacity; j++ )
+            {
+                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
+                    (bOldDeleted[j/32]&(1<<(j%32)))==0 )
+                {
+                    va.destroy( &aOldValues[j] );
+                    ka.destroy( &aOldKeys[j] );
+                }
+            }
+            va.deallocate( aOldValues, nOldCapacity );
+            ka.deallocate( aOldKeys, nOldCapacity );
+            ca.deallocate( bOldFilled, nOldKeysSize );
+            ca.deallocate( bOldDeleted, nOldKeysSize );
+            ca.deallocate( aOldHashCodes, nOldCapacity );
+        }
+
+        bool isFilled( uint32_t loc ) const
+        {
+            if( loc >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return (bFilled[loc/32]&(1<<(loc%32)))!=0;
+        }
+
+        bool isDeleted( uint32_t loc ) const
+        {
+            if( loc >= nCapacity )
+                throw HashException("Referenced position invalid.");
+            return (bDeleted[loc/32]&(1<<(loc%32)))!=0;
+        }
+
+        void clear()
+        {
+            for( uint32_t j = 0; j < nCapacity; j++ )
+            {
+                if( isFilled( j ) )
+                    if( !isDeleted( j ) )
+                    {
+                        va.destroy( &aValues[j] );
+                        ka.destroy( &aKeys[j] );
+                    }
+            }
+            va.deallocate( aValues, nCapacity );
+            ka.deallocate( aKeys, nCapacity );
+            ca.deallocate( bFilled, nKeysSize );
+            ca.deallocate( bDeleted, nKeysSize );
+            ca.deallocate( aHashCodes, nCapacity );
+            
+            bFilled = NULL;
+            bDeleted = NULL;
+            aKeys = NULL;
+            aValues = NULL;
+            aHashCodes = NULL;
+            
+            nCapacity = 0;
+            nFilled = 0;
+            nDeleted = 0;
+        }
+
+        uint32_t nCapacity;
+        uint32_t nFilled;
+        uint32_t nDeleted;
+        uint32_t *bFilled;
+        uint32_t *bDeleted;
+        uint32_t nKeysSize;
+        key *aKeys;
+        value *aValues;
+        uint32_t *aHashCodes;
+        valuealloc va;
+        keyalloc ka;
+        challoc ca;
+        sizecalc szCalc;
+    };
+    /** @endcond */
+
+    /**
+     * Libbu++ Template Hash Table.  This is your average hash table, that uses
+     * template functions in order to do fast, efficient, generalized hashing.
+     * It's pretty easy to use, and works well with all other libbu++ types so
+     * far.
+     *
+     * In order to use it, I recommend the following for all basic usage:
+     *@code
+     // Define a Hash typedef with strings as keys and ints as values.
+     typedef Bu::Hash<Bu::String, int> StrIntHash;
+
+     // Create one
+     StrIntHash hInts;
+
+     // Insert some integers
+     hInts["one"] = 1;
+     hInts["forty-two"] = 42;
+     hInts.insert("forty two", 42 );
+
+     // Get values out of the hash, the last two options are the most explicit,
+     // and must be used if the hash's value type does not match what you're
+     // comparing to exactly.
+     if( hInts["one"] == 1 ) doSomething();
+     if( hInts["forty-two"].value() == 42 ) doSomething();
+     if( hInts.get("forty two") == 42 ) doSomething();
+
+     // Iterate through the Hash
+     for( StrIntHash::iterator i = hInts.begin(); i != hInts.end(); i++ )
+     {
+        // i.getValue() works too
+        print("'%s' = %d\n", i.getKey().getStr(), (*i) );
+     }
+                                                    
+     @endcode
+     *@param key (typename) The datatype of the hashtable keys
+     *@param value (typename) The datatype of the hashtable data
+     *@param sizecalc (typename) Functor to compute new table size on rehash
+     *@param keyalloc (typename) Memory allocator for hashtable keys
+     *@param valuealloc (typename) Memory allocator for hashtable values
+     *@param challoc (typename) Byte allocator for bitflags
+     *@ingroup Containers
+     */
+    template<typename key, typename value,
+        typename sizecalc = __calcNextTSize_fast,
+        typename keyalloc = std::allocator<key>,
+        typename valuealloc = std::allocator<value>,
+        typename challoc = std::allocator<uint32_t>
+        >
+    class Hash : public SharedCore<
+                 Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>,
+                 HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc>
+                 >
+    {
+    private:
+        typedef class HashCore<key, value, sizecalc, keyalloc, valuealloc, challoc> Core;
+        typedef class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> MyType;
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_resetCore;
+        using SharedCore<MyType, Core>::_allocateCore;
+    
+    public:
+        Hash()
+        {
+        }
+
+        Hash( const MyType &src ) :
+            SharedCore<MyType, Core >( src )
+        {
+        }
+
+        virtual ~Hash()
+        {
+        }
+
+        /**
+         * Get the current hash table capacity. (Changes at re-hash)
+         *@returns (uint32_t) The current capacity.
+         */
+        uint32_t getCapacity() const
+        {
+            return core->nCapacity;
+        }
+
+        /**
+         * Get the number of hash locations spoken for. (Including 
+         * not-yet-cleaned-up deleted items.)
+         *@returns (uint32_t) The current fill state.
+         */
+        uint32_t getFill() const
+        {
+            return core->nFilled;
+        }
+
+        /**
+         * Get the number of items stored in the hash table.
+         *@returns (uint32_t) The number of items stored in the hash table.
+         */
+        uint32_t getSize() const
+        {
+            return core->nFilled-core->nDeleted;
+        }
+
+        bool isEmpty() const
+        {
+            return (core->nFilled-core->nDeleted) == 0;
+        }
+
+        /**
+         * Get the number of items which have been deleted, but not yet
+         * cleaned up.
+         *@returns (uint32_t) The number of deleted items.
+         */
+        uint32_t getDeleted() const
+        {
+            return core->nDeleted;
+        }
+
+        struct HashProxy
+        {
+        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+        private:
+            HashProxy( MyType &h, const key *k, uint32_t nPos, uint32_t hash ) :
+                hsh( h ),
+                pKey( k ),
+                nPos( nPos ),
+                hash( hash ),
+                bFilled( false )
+            {
+            }
+
+            HashProxy( MyType &h, uint32_t nPos, value *pValue ) :
+                hsh( h ),
+                nPos( nPos ),
+                pValue( pValue ),
+                bFilled( true )
+            {
+            }
+
+            MyType &hsh;
+            const key *pKey;
+            uint32_t nPos;
+            value *pValue;
+            uint32_t hash;
+            bool bFilled;
+
+        public:
+            /**
+             * Cast operator for HashProxy.
+             *@returns (value_type &) The value the HashProxy is pointing to.
+             */
+            operator value &()
+            {
+                if( bFilled == false )
+                    throw HashException(
+                            excodeNotFilled,
+                            "No data associated with that key."
+                            );
+                return *pValue;
+            }
+
+            /**
+             * Direct function for retrieving a value out of the HashProxy.
+             *@returns (value_type &) The value pointed to by this HashProxy.
+             */
+            value &getValue()
+            {
+                if( bFilled == false )
+                    throw HashException(
+                            excodeNotFilled,
+                            "No data associated with that key."
+                            );
+                return *pValue;
+            }
+
+            /**
+             * Whether this HashProxy points to something real or not.
+             */
+            bool isFilled()
+            {
+                return bFilled;
+            }
+
+            /**
+             * Erase the data pointed to by this HashProxy.
+             */
+            void erase()
+            {
+                if( bFilled )
+                {
+                    hsh.core->_erase( nPos );
+                }
+            }
+
+            /**
+             * Assign data to this point in the hash table.
+             *@param nval (value_type) the data to assign.
+             */
+            value operator=( value nval )
+            {
+                if( bFilled )
+                {
+                    hsh.core->va.destroy( &hsh.core->aValues[nPos] );
+                    hsh.core->va.construct( &hsh.core->aValues[nPos], nval );
+                }
+                else
+                {
+                    hsh.core->fill( nPos, *pKey, nval, hash ); 
+                }
+
+                return nval;
+            }
+
+            /**
+             * Pointer extraction operator. Access to members of data pointed to
+             *      by HashProxy.
+             *@returns (value_type *)
+             */
+            value *operator->()
+            {
+                if( bFilled == false )
+                    throw HashException(
+                            excodeNotFilled,
+                            "No data associated with that key."
+                            );
+                return pValue;
+            }
+        };
+
+        /**
+         * Hash table index operator
+         *@param k (key_type) Key of data to be retrieved.
+         *@returns (HashProxy) Proxy pointing to the data.
+         */
+        HashProxy operator[]( const key &k )
+        {
+            _hardCopy();
+
+            uint32_t hash = __calcHashCode( k );
+            bool bFill;
+            uint32_t nPos = core->probe( hash, k, bFill );
+
+            if( bFill )
+            {
+                return HashProxy( *this, nPos, &core->aValues[nPos] );
+            }
+            else
+            {
+                return HashProxy( *this, &k, nPos, hash );
+            }
+        }
+
+        /**
+         * Insert a value (v) under key (k) into the hash table
+         *@param k (key_type) Key to list the value under.
+         *@param v (value_type) Value to store in the hash table.
+         */
+        void insert( const key &k, const value &v )
+        {
+            _hardCopy();
+
+            core->insert( k, v );
+        }
+
+        /**
+         * Remove a value from the hash table.
+         *@param k (key_type) The data under this key will be erased.
+         */
+        void erase( const key &k )
+        {
+            _hardCopy();
+
+            uint32_t hash = __calcHashCode( k );
+            bool bFill;
+            uint32_t nPos = core->probe( hash, k, bFill );
+
+            if( bFill )
+            {
+                core->_erase( nPos );
+            }
+        }
+
+        struct iterator;
+
+        /**
+         * Remove a value from the hash pointed to from an iterator.
+         *@param i (iterator &) The data to be erased.
+         */
+        void erase( struct iterator &i )
+        {
+            if( this != i.hsh )
+                throw HashException("This iterator didn't come from this Hash.");
+            
+            _hardCopy();
+
+            if( core->isFilled( i.nPos ) && !core->isDeleted( i.nPos ) )
+            {
+                core->_erase( i.nPos );
+            }
+        }
+
+        /**
+         * Remove all data from the hash table.
+         */
+        virtual void clear()
+        {
+            _resetCore();
+        }
+
+        /**
+         * Get an item of data from the hash table.
+         *@param k (key_type) Key pointing to the data to be retrieved.
+         *@returns (value_type &) The data pointed to by (k).
+         */
+        value &get( const key &k )
+        {
+            _hardCopy();
+
+            uint32_t hash = __calcHashCode( k );
+            bool bFill;
+            uint32_t nPos = core->probe( hash, k, bFill, false );
+
+            if( bFill )
+            {
+                return core->aValues[nPos];
+            }
+            else
+            {
+                throw HashException(
+                        excodeNotFilled,
+                        "No data associated with that key."
+                        );
+            }
+        }
+        
+        /**
+         * Get a const item of data from the hash table.
+         *@param k (key_type) Key pointing to the data to be retrieved.
+         *@returns (const value_type &) A const version of the data pointed
+         *      to by (k).
+         */
+        const value &get( const key &k ) const
+        {
+            uint32_t hash = __calcHashCode( k );
+            bool bFill;
+            uint32_t nPos = core->probe( hash, k, bFill );
+
+            if( bFill )
+            {
+                return core->aValues[nPos];
+            }
+            else
+            {
+                throw HashException(
+                        excodeNotFilled,
+                        "No data associated with that key."
+                        );
+            }
+        }
+
+        /**
+         * Does the hash table contain an item under key (k).
+         *@param k (key_type) The key to check.
+         *@returns (bool) Whether there was an item in the hash under key (k).
+         */
+        bool has( const key &k ) const
+        {
+            bool bFill;
+            core->probe( __calcHashCode( k ), k, bFill );
+
+            return bFill;
+        }
+
+        /**
+         * Iteration structure for iterating through the hash.
+         */
+        typedef struct iterator
+        {
+            friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+        private:
+            iterator( MyType *hsh ) :
+                hsh( hsh ),
+                nPos( 0 ),
+                bFinished( false )
+            {
+                nPos = hsh->core->getFirstPos( bFinished );
+            }
+            
+            iterator( MyType *hsh, bool bDone ) :
+                hsh( hsh ),
+                nPos( 0 ),
+                bFinished( bDone )
+            {
+            }
+
+            MyType *hsh;
+            uint32_t nPos;
+            bool bFinished;
+
+        public:
+            iterator( const iterator &i ) :
+                hsh( i.hsh ),
+                nPos( i.nPos ),
+                bFinished( i.bFinished )
+            {
+            }
+
+            iterator() :
+                hsh( NULL ),
+                nPos( NULL ),
+                bFinished( true )
+            {
+            }
+
+            bool isValid() const
+            {
+                return !bFinished;
+            }
+
+            operator bool() const
+            {
+                return !bFinished;
+            }
+
+            /**
+             * Iterator incrementation operator. Move the iterator forward.
+             */
+            iterator operator++( int )
+            {
+                if( bFinished == false )
+                    nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                return *this;
+            }
+            
+            /**
+             * Iterator incrementation operator. Move the iterator forward.
+             */
+            iterator operator++()
+            {
+                if( bFinished == false )
+                    nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                return *this;
+            }
+
+            /**
+             * Iterator equality comparison operator. Iterators the same?
+             */
+            bool operator==( const iterator &oth ) const
+            {
+                if( bFinished != oth.bFinished )
+                    return false;
+                if( bFinished == true )
+                {
+                    return true;
+                }
+                else
+                {
+                    if( oth.nPos == nPos )
+                        return true;
+                    return false;
+                }
+            }
+            
+            /**
+             * Iterator not equality comparison operator. Not the same?
+             */
+            bool operator!=( const iterator &oth ) const
+            {
+                return !(*this == oth );
+            }
+
+            /**
+             * Iterator assignment operator.
+             */
+            iterator operator=( const iterator &oth )
+            {
+                hsh = oth.hsh;
+                nPos = oth.nPos;
+                bFinished = oth.bFinished;
+                return *this;
+            }
+
+            /**
+             * Iterator dereference operator... err.. get the value
+             *@returns (value_type &) The value behind this iterator.
+             */
+            value &operator *()
+            {
+                hsh->_hardCopy();
+                return hsh->core->getValueAtPos( nPos );
+            }
+
+            const value &operator *() const
+            {
+                return hsh->core->getValueAtPos( nPos );
+            }
+            
+            /**
+             * Get the key behind this iterator.
+             *@returns (key_type &) The key behind this iterator.
+             */
+            const key &getKey() const
+            {
+                return hsh->core->getKeyAtPos( nPos );
+            }
+
+            /**
+             * Get the value behind this iterator.
+             *@returns (value_type &) The value behind this iterator.
+             */
+            value &getValue()
+            {
+                hsh->_hardCopy();
+                return hsh->core->getValueAtPos( nPos );
+            }
+
+            /**
+             * Get the value behind this iterator.
+             *@returns (value_type &) The value behind this iterator.
+             */
+            const value &getValue() const
+            {
+                return hsh->core->getValueAtPos( nPos );
+            }
+        } iterator;
+        
+        /**
+         * Iteration structure for iterating through the hash (const).
+         */
+        typedef struct const_iterator
+        {
+            friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+        private:
+            const_iterator( const MyType *hsh ) :
+                hsh( hsh ),
+                nPos( 0 ),
+                bFinished( false )
+            {
+                nPos = hsh->core->getFirstPos( bFinished );
+            }
+            
+            const_iterator( const MyType *hsh, bool bDone ) :
+                hsh( hsh ),
+                nPos( 0 ),
+                bFinished( bDone )
+            {
+            }
+
+            const MyType *hsh;
+            uint32_t nPos;
+            bool bFinished;
+
+        public:
+            const_iterator() :
+                hsh( NULL ),
+                nPos( 0 ),
+                bFinished( true )
+            {
+            }
+
+            const_iterator( const const_iterator &src ) :
+                hsh( src.hsh ),
+                nPos( src.nPos ),
+                bFinished( src.bFinished )
+            {
+            }
+
+            const_iterator( const iterator &src ) :
+                hsh( src.hsh ),
+                nPos( src.nPos ),
+                bFinished( src.bFinished )
+            {
+            }
+
+            bool isValid() const
+            {
+                return !bFinished;
+            }
+
+            operator bool() const
+            {
+                return !bFinished;
+            }
+
+            /**
+             * Iterator incrementation operator. Move the iterator forward.
+             */
+            const_iterator operator++( int )
+            {
+                if( bFinished == false )
+                    nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                return *this;
+            }
+            
+            /**
+             * Iterator incrementation operator. Move the iterator forward.
+             */
+            const_iterator operator++()
+            {
+                if( bFinished == false )
+                    nPos = hsh->core->getNextPos( nPos, bFinished );
+
+                return *this;
+            }
+
+            /**
+             * Iterator equality comparison operator. Iterators the same?
+             */
+            bool operator==( const const_iterator &oth ) const
+            {
+                if( bFinished != oth.bFinished )
+                    return false;
+                if( bFinished == true )
+                {
+                    return true;
+                }
+                else
+                {
+                    if( oth.nPos == nPos )
+                        return true;
+                    return false;
+                }
+            }
+            
+            /**
+             * Iterator not equality comparison operator. Not the same?
+             */
+            bool operator!=( const const_iterator &oth ) const
+            {
+                return !(*this == oth );
+            }
+
+            /**
+             * Iterator assignment operator.
+             */
+            const_iterator operator=( const const_iterator &oth )
+            {
+                hsh = oth.hsh;
+                nPos = oth.nPos;
+                bFinished = oth.bFinished;
+                return *this;
+            }
+
+            /**
+             * Iterator dereference operator... err.. get the value
+             *@returns (value_type &) The value behind this iterator.
+             */
+            const value &operator *() const
+            {
+                return hsh->core->getValueAtPos( nPos );
+            }
+            
+            /**
+             * Get the key behind this iterator.
+             *@returns (key_type &) The key behind this iterator.
+             */
+            const key &getKey() const
+            {
+                return hsh->core->getKeyAtPos( nPos );
+            }
+
+            /**
+             * Get the value behind this iterator.
+             *@returns (value_type &) The value behind this iterator.
+             */
+            const value &getValue() const
+            {
+                return hsh->core->getValueAtPos( nPos );
+            }
+        } const_iterator;
+
+        /**
+         * Get an iterator pointing to the first item in the hash table.
+         *@returns (iterator) An iterator pointing to the first item in the
+         *      hash table.
+         */
+        iterator begin()
+        {
+            return iterator( this );
+        }
+        
+        const_iterator begin() const
+        {
+            return const_iterator( this );
+        }
+        
+        /**
+         * Get an iterator pointing to a point just past the last item in the
+         *      hash table.
+         *@returns (iterator) An iterator pointing to a point just past the
+         *      last item in the hash table.
+         */
+        iterator end()
+        {
+            return iterator( this, true );
+        }
+        
+        const_iterator end() const
+        {
+            return const_iterator( this, true );
+        }
+
+        /**
+         * Get a list of all the keys in the hash table.
+         *@returns (std::list<key_type>) The list of keys in the hash table.
+         */
+        Bu::List<key> getKeys() const
+        {
+            Bu::List<key> lKeys;
+
+            for( uint32_t j = 0; j < core->nCapacity; j++ )
+            {
+                if( core->isFilled( j ) )
+                {
+                    if( !core->isDeleted( j ) )
+                    {
+                        lKeys.append( core->aKeys[j] );
+                    }
+                }
+            }
+
+            return lKeys;
+        }
+        
+        Bu::List<value> getValues() const
+        {
+            Bu::List<value> lValues;
+
+            for( uint32_t j = 0; j < core->nCapacity; j++ )
+            {
+                if( core->isFilled( j ) )
+                {
+                    if( !core->isDeleted( j ) )
+                    {
+                        lValues.append( core->aValues[j] );
+                    }
+                }
+            }
+
+            return lValues;
+        }
+
+        bool operator==( const MyType &rhs ) const
+        {
+            if( this == &rhs )
+                return true;
+            if( core == rhs.core )
+                return true;
+            if( core == NULL || rhs.core == NULL )
+                return false;
+            if( getSize() != rhs.getSize() )
+                return false;
+
+            for( uint32_t j = 0; j < core->nCapacity; j++ )
+            {
+                if( core->isFilled( j ) )
+                {
+                    if( !core->isDeleted( j ) )
+                    {
+                        // Check to see if this key is in the other hash
+                        if( rhs.has( core->aKeys[j] ) )
+                        {
+                            if( !(core->aValues[j] == rhs.get( core->aKeys[j]) ) )
+                            {
+                                return false;
+                            }
+                        }
+                        else
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        bool operator!=( const MyType &rhs ) const
+        {
+            return !(*this == rhs);
+        }
+
+        MyType &operator+=( const MyType &rhs )
+        {
+            if( this == &rhs )
+                return *this;
+            if( core == rhs.core )
+                return *this;
+            if( core == NULL || rhs.core == NULL )
+                return *this;
+
+            for( const_iterator i = rhs.begin(); i; i++ )
+                insert( i.getKey(), i.getValue() );
+
+            return *this;
+        }
+
+    protected:
+        virtual Core *_copyCore( Core *src )
+        {
+            Core *pRet = _allocateCore();
+
+            pRet->nFilled = 0;
+            pRet->nDeleted = 0;
+            pRet->nCapacity = src->nCapacity;
+            pRet->nKeysSize = bitsTo<uint32_t>( pRet->nCapacity );
+            pRet->bFilled = pRet->ca.allocate( pRet->nKeysSize );
+            pRet->bDeleted = pRet->ca.allocate( pRet->nKeysSize );
+            pRet->clearBits();
+
+            pRet->aHashCodes = pRet->ca.allocate( pRet->nCapacity );
+            pRet->aKeys = pRet->ka.allocate( pRet->nCapacity );
+            pRet->aValues = pRet->va.allocate( pRet->nCapacity );
+
+            for( uint32_t j = 0; j < src->nCapacity; j++ )
+            {
+                if( src->isFilled( j ) && !src->isDeleted( j ) )
+                {
+                    pRet->insert( src->aKeys[j], src->aValues[j] );
+                }
+            }
+
+            return pRet;
+        }
+    };
+    
+    template<typename T> uint32_t __calcHashCode( const T &k )
+    {
+        return static_cast<uint32_t>( k );
+    }
+
+    template<typename T> bool __cmpHashKeys( const T &a, const T &b )
+    {
+        return (a == b);
+    }
+
+    template<> uint32_t __calcHashCode<const char *>( const char * const &k );
+    template<> bool __cmpHashKeys<const char *>( const char * const &a, const char * const &b );
+
+    template<> uint32_t __calcHashCode<char *>( char * const &k );
+    template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b );
+
+    class Formatter;
+    Formatter &operator<<( Formatter &rOut, char *sStr );
+    Formatter &operator<<( Formatter &rOut, signed char c );
+    template<typename key, typename value>
+    Formatter &operator<<( Formatter &f, const Bu::Hash<key, value> &l )
+    {
+        f << '{';
+        for( typename Bu::Hash<key,value>::const_iterator i = l.begin(); i; i++ )
+        {
+            if( i != l.begin() )
+                f << ", ";
+            f << i.getKey() << ": " << i.getValue();
+        }
+        f << '}';
+
+        return f;
+    }
+
+    template<typename key, typename value, typename a, typename b,
+        typename c, typename d>
+    ArchiveBase &operator<<( ArchiveBase &ar, const Hash<key,value,a,b,c,d> &h )
+    {
+        long iSize = h.getSize();
+        ar << iSize;
+        for( typename Hash<key,value,a,b,c,d>::const_iterator i = h.begin(); i != h.end(); i++ )
+        {
+            ar << (i.getKey());
+            ar << (i.getValue());
+        }
+
+        return ar;
+    }
+
+    template<typename key, typename value, typename a, typename b,
+        typename c, typename d>
+    ArchiveBase &operator>>( ArchiveBase &ar, Hash<key,value,a,b,c,d> &h )
+    {
+        h.clear();
+        long nSize;
+        ar >> nSize;
+
+        for( long j = 0; j < nSize; j++ )
+        {
+            key k; value v;
+            ar >> k >> v;
+            h.insert( k, v );
+        }
+
+        return ar;
+    }
 }
 
 #endif
diff --git a/src/stable/heap.h b/src/stable/heap.h
index a813f92..5033618 100644
--- a/src/stable/heap.h
+++ b/src/stable/heap.h
@@ -17,596 +17,596 @@
 
 namespace Bu
 {
-        subExceptionDecl( HeapException );
-
-        template<typename item, typename cmpfunc, typename itemalloc>
-        class Heap;
-
-        /** @cond DEVEL */
-        template<typename item, typename cmpfunc, typename itemalloc>
-        class HeapCore
-        {
-        friend class Heap<item, cmpfunc, itemalloc>;
-        friend class SharedCore<
-                Heap<item, cmpfunc, itemalloc>, HeapCore<item, cmpfunc, itemalloc>
-                >;
-        private:
-                HeapCore() :
-                        iSize( 0 ),
-                        iFill( 0 ),
-                        aItem( NULL )
-                {
-                }
-
-                virtual ~HeapCore()
-                {
-                        clear();
-                }
-
-                void init()
-                {
-                        if( iSize > 0 )
-                                return;
-
-                        iSize = 7;
-                        iFill = 0;
-                        aItem = ia.allocate( iSize );
-                }
-
-                void init( int iCap )
-                {
-                        if( iSize > 0 )
-                                return;
-
-                        for( iSize = 1; iSize < iCap; iSize=iSize*2+1 ) { }
-                        iFill = 0;
-                        aItem = ia.allocate( iSize );
-                }
-
-                void clear()
-                {
-                        if( iSize == 0 )
-                                return;
-
-                        for( int j = 0; j < iFill; j++ )
-                                ia.destroy( &aItem[j] );
-                        ia.deallocate( aItem, iSize );
-                        aItem = NULL;
-                        iSize = 0;
-                        iFill = 0;
-                }
-                
-                void upSize()
-                {
-                        if( iSize == 0 )
-                        {
-                                init();
-                                return;
-                        }
-
-                        item *aNewItems = ia.allocate( iSize*2+1 );
-                        //
-                        // We cannot use a memcopy here because we don't know what kind
-                        // of datastructures are being used, we have to copy them one at
-                        // a time.
-                        //
-                        for( int j = 0; j < iFill; j++ )
-                        {
-                                ia.construct( &aNewItems[j], aItem[j] );
-                                ia.destroy( &aItem[j] );
-                        }
-                        ia.deallocate( aItem, iSize );
-                        aItem = aNewItems;
-                        iSize = iSize*2+1;
-                }
-                
-                virtual void enqueue( const item &it )
-                {
-                        item i = it; // TODO: This is a silly workaround, put the i item
-                                                 // at the end.
-                        if( iFill+1 >= iSize )
-                                upSize();
-
-                        for( int j = 0; j < iFill; )
-                        {
-                                if( cmp( i, aItem[j] ) )
-                                {
-                                        Bu::swap( i, aItem[j] );
-                                }
-
-                                if( j*2+1 >= iFill )
-                                        break;
-                                if( cmp( i, aItem[j*2+1] ) )
-                                {
-                                        j = j*2+1;
-                                }
-                                else
-                                {
-                                        j = j*2+2;
-                                }
-                        }
-                        ia.construct( &aItem[iFill], i );
-                        if( iFill > 0 )
-                        {
-                                for( int j = iFill; j >= 0; )
-                                {
-                                        int k = (j-1)/2;
-                                        if( j == k )
-                                                break;
-                                        if( cmp( aItem[k], aItem[j] ) )
-                                                break;
-
-                                        Bu::swap( aItem[k], aItem[j] );
-                                        j = k;
-                                }
-                        }
-                        iFill++;
-                }
-
-                virtual item dequeue()
-                {
-                        if( iFill == 0 )
-                                throw HeapException("Heap empty.");
-                        item iRet = aItem[0];
-                        int j;
-                        for( j = 0; j < iFill; )
-                        {
-                                int k = j*2+1;
-                                if( k+1 < iFill && cmp( aItem[k+1], aItem[k] ) )
-                                {
-                                        if( k+1 < iFill-1 && cmp( aItem[iFill-1], aItem[k+1] ) )
-                                                break;
-                                        aItem[j] = aItem[k+1];
-                                        j = k+1;
-                                }
-                                else if( k < iFill )
-                                {
-                                        if( k < iFill-1 && cmp( aItem[iFill-1], aItem[k] ) )
-                                                break;
-                                        aItem[j] = aItem[k];
-                                        j = k;
-                                }
-                                else
-                                        break;
-                        }
-                        if( j < iFill-1 )
-                                aItem[j] = aItem[iFill-1];
-                        ia.destroy( &aItem[iFill-1] );
-                        iFill--;
-
-                        return iRet;
-                }
-
-        private:
-                int iSize;
-                int iFill;
-                item *aItem;
-                cmpfunc cmp;
-                itemalloc ia;
-        };
-        /** @endcond */
-
-        /**
-         * A priority queue that allows for an unlimited number of priorities.  All
-         * objects enqueued must support less-than-comparison.  Then every time an
-         * item is dequeued it is always the least item in the heap.  The heap
-         * operates using a binary tree for storage, which allows most operations
-         * to be very fast.  Enqueueing and dequeueing are both O(log(N)) operatoins
-         * whereas peeking is constant time.
-         *
-         * This heap implementation allows iterating, however please note that any
-         * enqueue or dequeue operation will invalidate the iterator and make it
-         * unusable (if it still works, you shouldn't trust the results).  Also,
-         * the items are not stored in memory in order, they are optomized into a
-         * tree.  This means that the items will be in effectively random order
-         * while iterating through them, and the order cannot be trusted.  Also,
-         * modifying an item in the heap will not cause that item to be re-sorted.
-         * If you want to change the position of an item in the heap you will have
-         * to dequeue every item before it, dequeue that item, change it, and
-         * re-enqueue all of the items removed.
-         */
-        template<typename item, typename cmpfunc=__basicLTCmp<item>, typename itemalloc=std::allocator<item> >
-        class Heap : public Queue<item>, public SharedCore<
-                                 Heap<item, cmpfunc, itemalloc>,
-                                 HeapCore<item, cmpfunc, itemalloc>
-                                 >
-        {
-        private:
-                typedef class Heap<item,cmpfunc,itemalloc> MyType;
-                typedef class HeapCore<item,cmpfunc,itemalloc> Core;
-
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_resetCore;
-                using SharedCore<MyType, Core>::_allocateCore;
-
-        public:
-                Heap()
-                {
-                }
-                
-                Heap( cmpfunc cmpin )
-                {
-                        core->cmp = cmpin;
-                }
-
-                Heap( int iInitialCapacity )
-                {
-                        core->init( iInitialCapacity );
-                }
-                
-                Heap( cmpfunc cmpin, int iInitialCapacity )
-                {
-                        core->cmp = cmpin;
-                        core->init( iInitialCapacity );
-                }
-
-                Heap( const MyType &rSrc ) :
-                        SharedCore<MyType, Core>( rSrc )
-                {
-                }
-
-                virtual ~Heap()
-                {
-                }
-
-                virtual void enqueue( const item &it )
-                {
-                        _hardCopy();
-
-                        core->enqueue( it );
-                }
-
-                virtual item &peek()
-                {
-                        _hardCopy();
-
-                        if( core->iFill == 0 )
-                                throw HeapException("Heap empty.");
-                        return core->aItem[0];
-                }
-
-                virtual const item &peek() const
-                {
-                        if( core->iFill == 0 )
-                                throw HeapException("Heap empty.");
-                        return core->aItem[0];
-                }
-
-                virtual item dequeue()
-                {
-                        _hardCopy();
-
-                        return core->dequeue();
-                }
-
-                virtual bool isEmpty() const
-                {
-                        return (core->iFill==0);
-                }
-
-                virtual int getSize() const
-                {
-                        return core->iFill;
-                }
-
-                class iterator
-                {
-                        friend class const_iterator;
-                        friend class Heap<item, cmpfunc, itemalloc>;
-                private:
-                        Heap<item, cmpfunc, itemalloc> *pHeap;
-                        int iIndex;
-
-                        iterator( Heap<item, cmpfunc, itemalloc> *pHeap, int iIndex ) :
-                                pHeap( pHeap ), iIndex( iIndex )
-                        {
-                        }
-
-                        void checkValid()
-                        {
-                                if( pHeap == NULL )
-                                        throw Bu::ExceptionBase("Iterator not initialized.");
-                                if( iIndex < 0 || iIndex >= pHeap->core->iFill )
-                                        throw Bu::ExceptionBase("Iterator out of bounds.");
-                        }
-
-                public:
-                        iterator() :
-                                pHeap( NULL ),
-                                iIndex( -1 )
-                        {
-                        }
-
-                        iterator( const iterator &i ) :
-                                pHeap( i.pHeap ),
-                                iIndex( i.iIndex )
-                        {
-                        }
-
-                        bool operator==( const iterator &oth ) const
-                        {
-                                return (oth.pHeap == pHeap) && (oth.iIndex == iIndex);
-                        }
-
-                        bool operator!=( const iterator &oth ) const
-                        {
-                                return (oth.pHeap != pHeap) || (oth.iIndex != iIndex);
-                        }
-
-                        item &operator*()
-                        {
-                                pHeap->_hardCopy();
-
-                                return pHeap->core->aItem[iIndex];
-                        }
-
-                        item *operator->()
-                        {
-                                pHeap->_hardCopy();
-
-                                return &(pHeap->core->aItem[iIndex]);
-                        }
-
-                        iterator &operator++()
-                        {
-                                checkValid();
-                                iIndex++;
-                                if( iIndex >= pHeap->iFill )
-                                        iIndex = -1;
-
-                                return *this;
-                        }
-
-                        iterator &operator--()
-                        {
-                                checkValid();
-                                iIndex--;
-
-                                return *this;
-                        }
-                        
-                        iterator &operator++( int )
-                        {
-                                checkValid();
-                                iIndex++;
-                                if( iIndex >= pHeap->core->iFill )
-                                        iIndex = -1;
-
-                                return *this;
-                        }
-
-                        iterator &operator--( int )
-                        {
-                                checkValid();
-                                iIndex--;
-
-                                return *this;
-                        }
-
-                        iterator operator+( int iDelta )
-                        {
-                                checkValid();
-                                iterator ret( *this );
-                                ret.iIndex += iDelta;
-                                if( ret.iIndex >= pHeap->core->iFill )
-                                        ret.iIndex = -1;
-                                return ret;
-                        }
-
-                        iterator operator-( int iDelta )
-                        {
-                                checkValid();
-                                iterator ret( *this );
-                                ret.iIndex -= iDelta;
-                                if( ret.iIndex < 0 )
-                                        ret.iIndex = -1;
-                                return ret;
-                        }
-
-                        operator bool() const
-                        {
-                                return iIndex != -1;
-                        }
-
-                        bool isValid() const
-                        {
-                                return iIndex != -1;
-                        }
-
-                        iterator &operator=( const iterator &oth )
-                        {
-                                pHeap = oth.pHeap;
-                                iIndex = oth.iIndex;
-                        }
-                };
-                
-                class const_iterator
-                {
-                        friend class Heap<item, cmpfunc, itemalloc>;
-                private:
-                        Heap<item, cmpfunc, itemalloc> *pHeap;
-                        int iIndex;
-
-                        const_iterator( Heap<item, cmpfunc, itemalloc> *pHeap,
-                                        int iIndex ) :
-                                pHeap( pHeap ), iIndex( iIndex )
-                        {
-                        }
-
-                        void checkValid()
-                        {
-                                if( pHeap == NULL )
-                                        throw Bu::ExceptionBase("Iterator not initialized.");
-                                if( iIndex < 0 || iIndex >= pHeap->core->iFill )
-                                        throw Bu::ExceptionBase("Iterator out of bounds.");
-                        }
-
-                public:
-                        const_iterator() :
-                                pHeap( NULL ),
-                                iIndex( -1 )
-                        {
-                        }
-                        
-                        const_iterator( const const_iterator &i ) :
-                                pHeap( i.pHeap ),
-                                iIndex( i.iIndex )
-                        {
-                        }
-                        
-                        const_iterator( const iterator &i ) :
-                                pHeap( i.pHeap ),
-                                iIndex( i.iIndex )
-                        {
-                        }
-
-                        bool operator==( const const_iterator &oth ) const
-                        {
-                                return (oth.pHeap == pHeap) && (oth.iIndex == iIndex);
-                        }
-
-                        bool operator!=( const const_iterator &oth ) const
-                        {
-                                return (oth.pHeap != pHeap) || (oth.iIndex != iIndex);
-                        }
-
-                        const item &operator*()
-                        {
-                                pHeap->_hardCopy();
-
-                                return pHeap->core->aItem[iIndex];
-                        }
-
-                        const item *operator->()
-                        {
-                                pHeap->_hardCopy();
-
-                                return &(pHeap->core->aItem[iIndex]);
-                        }
-
-                        const_iterator &operator++()
-                        {
-                                checkValid();
-                                iIndex++;
-                                if( iIndex >= pHeap->core->iFill )
-                                        iIndex = -1;
-
-                                return *this;
-                        }
-
-                        const_iterator &operator--()
-                        {
-                                checkValid();
-                                iIndex--;
-
-                                return *this;
-                        }
-                        
-                        const_iterator &operator++( int )
-                        {
-                                checkValid();
-                                iIndex++;
-                                if( iIndex >= pHeap->core->iFill )
-                                        iIndex = -1;
-
-                                return *this;
-                        }
-
-                        const_iterator &operator--( int )
-                        {
-                                checkValid();
-                                iIndex--;
-
-                                return *this;
-                        }
-
-                        const_iterator operator+( int iDelta )
-                        {
-                                checkValid();
-                                const_iterator ret( *this );
-                                ret.iIndex += iDelta;
-                                if( ret.iIndex >= pHeap->iFill )
-                                        ret.iIndex = -1;
-                                return ret;
-                        }
-
-                        const_iterator operator-( int iDelta )
-                        {
-                                checkValid();
-                                const_iterator ret( *this );
-                                ret.iIndex -= iDelta;
-                                if( ret.iIndex < 0 )
-                                        ret.iIndex = -1;
-                                return ret;
-                        }
-
-                        operator bool() const
-                        {
-                                return iIndex != -1;
-                        }
-
-                        bool isValid() const
-                        {
-                                return iIndex != -1;
-                        }
-
-                        const_iterator &operator=( const const_iterator &oth )
-                        {
-                                pHeap = oth.pHeap;
-                                iIndex = oth.iIndex;
-                        }
-
-                        const_iterator &operator=( const iterator &oth )
-                        {
-                                pHeap = oth.pHeap;
-                                iIndex = oth.iIndex;
-                        }
-                };
-
-                iterator begin()
-                {
-                        if( core->iFill == 0 )
-                                return end();
-                        return iterator( this, 0 );
-                }
-
-                const_iterator begin() const
-                {
-                        if( core->iFill == 0 )
-                                return end();
-                        return const_iterator( this, 0 );
-                }
-
-                iterator end()
-                {
-                        return iterator( this, -1 );
-                }
-
-                const_iterator end() const
-                {
-                        return const_iterator( this, -1 );
-                }
-
-
-        protected:
-                virtual Core *_copyCore( Core *src )
-                {
-                        Core *pRet = _allocateCore();
-
-                        pRet->iSize = src->iSize;
-                        pRet->iFill = src->iFill;
-                        pRet->cmp = src->cmp;
-                        pRet->aItem = pRet->ia.allocate( pRet->iSize );
-                        for( int j = 0; j < pRet->iFill; j++ )
-                        {
-                                pRet->ia.construct( &pRet->aItem[j], src->aItem[j] );
-                        }
-
-                        return pRet;
-                }
-        };
+    subExceptionDecl( HeapException );
+
+    template<typename item, typename cmpfunc, typename itemalloc>
+    class Heap;
+
+    /** @cond DEVEL */
+    template<typename item, typename cmpfunc, typename itemalloc>
+    class HeapCore
+    {
+    friend class Heap<item, cmpfunc, itemalloc>;
+    friend class SharedCore<
+        Heap<item, cmpfunc, itemalloc>, HeapCore<item, cmpfunc, itemalloc>
+        >;
+    private:
+        HeapCore() :
+            iSize( 0 ),
+            iFill( 0 ),
+            aItem( NULL )
+        {
+        }
+
+        virtual ~HeapCore()
+        {
+            clear();
+        }
+
+        void init()
+        {
+            if( iSize > 0 )
+                return;
+
+            iSize = 7;
+            iFill = 0;
+            aItem = ia.allocate( iSize );
+        }
+
+        void init( int iCap )
+        {
+            if( iSize > 0 )
+                return;
+
+            for( iSize = 1; iSize < iCap; iSize=iSize*2+1 ) { }
+            iFill = 0;
+            aItem = ia.allocate( iSize );
+        }
+
+        void clear()
+        {
+            if( iSize == 0 )
+                return;
+
+            for( int j = 0; j < iFill; j++ )
+                ia.destroy( &aItem[j] );
+            ia.deallocate( aItem, iSize );
+            aItem = NULL;
+            iSize = 0;
+            iFill = 0;
+        }
+        
+        void upSize()
+        {
+            if( iSize == 0 )
+            {
+                init();
+                return;
+            }
+
+            item *aNewItems = ia.allocate( iSize*2+1 );
+            //
+            // We cannot use a memcopy here because we don't know what kind
+            // of datastructures are being used, we have to copy them one at
+            // a time.
+            //
+            for( int j = 0; j < iFill; j++ )
+            {
+                ia.construct( &aNewItems[j], aItem[j] );
+                ia.destroy( &aItem[j] );
+            }
+            ia.deallocate( aItem, iSize );
+            aItem = aNewItems;
+            iSize = iSize*2+1;
+        }
+        
+        virtual void enqueue( const item &it )
+        {
+            item i = it; // TODO: This is a silly workaround, put the i item
+                         // at the end.
+            if( iFill+1 >= iSize )
+                upSize();
+
+            for( int j = 0; j < iFill; )
+            {
+                if( cmp( i, aItem[j] ) )
+                {
+                    Bu::swap( i, aItem[j] );
+                }
+
+                if( j*2+1 >= iFill )
+                    break;
+                if( cmp( i, aItem[j*2+1] ) )
+                {
+                    j = j*2+1;
+                }
+                else
+                {
+                    j = j*2+2;
+                }
+            }
+            ia.construct( &aItem[iFill], i );
+            if( iFill > 0 )
+            {
+                for( int j = iFill; j >= 0; )
+                {
+                    int k = (j-1)/2;
+                    if( j == k )
+                        break;
+                    if( cmp( aItem[k], aItem[j] ) )
+                        break;
+
+                    Bu::swap( aItem[k], aItem[j] );
+                    j = k;
+                }
+            }
+            iFill++;
+        }
+
+        virtual item dequeue()
+        {
+            if( iFill == 0 )
+                throw HeapException("Heap empty.");
+            item iRet = aItem[0];
+            int j;
+            for( j = 0; j < iFill; )
+            {
+                int k = j*2+1;
+                if( k+1 < iFill && cmp( aItem[k+1], aItem[k] ) )
+                {
+                    if( k+1 < iFill-1 && cmp( aItem[iFill-1], aItem[k+1] ) )
+                        break;
+                    aItem[j] = aItem[k+1];
+                    j = k+1;
+                }
+                else if( k < iFill )
+                {
+                    if( k < iFill-1 && cmp( aItem[iFill-1], aItem[k] ) )
+                        break;
+                    aItem[j] = aItem[k];
+                    j = k;
+                }
+                else
+                    break;
+            }
+            if( j < iFill-1 )
+                aItem[j] = aItem[iFill-1];
+            ia.destroy( &aItem[iFill-1] );
+            iFill--;
+
+            return iRet;
+        }
+
+    private:
+        int iSize;
+        int iFill;
+        item *aItem;
+        cmpfunc cmp;
+        itemalloc ia;
+    };
+    /** @endcond */
+
+    /**
+     * A priority queue that allows for an unlimited number of priorities.  All
+     * objects enqueued must support less-than-comparison.  Then every time an
+     * item is dequeued it is always the least item in the heap.  The heap
+     * operates using a binary tree for storage, which allows most operations
+     * to be very fast.  Enqueueing and dequeueing are both O(log(N)) operatoins
+     * whereas peeking is constant time.
+     *
+     * This heap implementation allows iterating, however please note that any
+     * enqueue or dequeue operation will invalidate the iterator and make it
+     * unusable (if it still works, you shouldn't trust the results).  Also,
+     * the items are not stored in memory in order, they are optomized into a
+     * tree.  This means that the items will be in effectively random order
+     * while iterating through them, and the order cannot be trusted.  Also,
+     * modifying an item in the heap will not cause that item to be re-sorted.
+     * If you want to change the position of an item in the heap you will have
+     * to dequeue every item before it, dequeue that item, change it, and
+     * re-enqueue all of the items removed.
+     */
+    template<typename item, typename cmpfunc=__basicLTCmp<item>, typename itemalloc=std::allocator<item> >
+    class Heap : public Queue<item>, public SharedCore<
+                 Heap<item, cmpfunc, itemalloc>,
+                 HeapCore<item, cmpfunc, itemalloc>
+                 >
+    {
+    private:
+        typedef class Heap<item,cmpfunc,itemalloc> MyType;
+        typedef class HeapCore<item,cmpfunc,itemalloc> Core;
+
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_resetCore;
+        using SharedCore<MyType, Core>::_allocateCore;
+
+    public:
+        Heap()
+        {
+        }
+        
+        Heap( cmpfunc cmpin )
+        {
+            core->cmp = cmpin;
+        }
+
+        Heap( int iInitialCapacity )
+        {
+            core->init( iInitialCapacity );
+        }
+        
+        Heap( cmpfunc cmpin, int iInitialCapacity )
+        {
+            core->cmp = cmpin;
+            core->init( iInitialCapacity );
+        }
+
+        Heap( const MyType &rSrc ) :
+            SharedCore<MyType, Core>( rSrc )
+        {
+        }
+
+        virtual ~Heap()
+        {
+        }
+
+        virtual void enqueue( const item &it )
+        {
+            _hardCopy();
+
+            core->enqueue( it );
+        }
+
+        virtual item &peek()
+        {
+            _hardCopy();
+
+            if( core->iFill == 0 )
+                throw HeapException("Heap empty.");
+            return core->aItem[0];
+        }
+
+        virtual const item &peek() const
+        {
+            if( core->iFill == 0 )
+                throw HeapException("Heap empty.");
+            return core->aItem[0];
+        }
+
+        virtual item dequeue()
+        {
+            _hardCopy();
+
+            return core->dequeue();
+        }
+
+        virtual bool isEmpty() const
+        {
+            return (core->iFill==0);
+        }
+
+        virtual int getSize() const
+        {
+            return core->iFill;
+        }
+
+        class iterator
+        {
+            friend class const_iterator;
+            friend class Heap<item, cmpfunc, itemalloc>;
+        private:
+            Heap<item, cmpfunc, itemalloc> *pHeap;
+            int iIndex;
+
+            iterator( Heap<item, cmpfunc, itemalloc> *pHeap, int iIndex ) :
+                pHeap( pHeap ), iIndex( iIndex )
+            {
+            }
+
+            void checkValid()
+            {
+                if( pHeap == NULL )
+                    throw Bu::ExceptionBase("Iterator not initialized.");
+                if( iIndex < 0 || iIndex >= pHeap->core->iFill )
+                    throw Bu::ExceptionBase("Iterator out of bounds.");
+            }
+
+        public:
+            iterator() :
+                pHeap( NULL ),
+                iIndex( -1 )
+            {
+            }
+
+            iterator( const iterator &i ) :
+                pHeap( i.pHeap ),
+                iIndex( i.iIndex )
+            {
+            }
+
+            bool operator==( const iterator &oth ) const
+            {
+                return (oth.pHeap == pHeap) && (oth.iIndex == iIndex);
+            }
+
+            bool operator!=( const iterator &oth ) const
+            {
+                return (oth.pHeap != pHeap) || (oth.iIndex != iIndex);
+            }
+
+            item &operator*()
+            {
+                pHeap->_hardCopy();
+
+                return pHeap->core->aItem[iIndex];
+            }
+
+            item *operator->()
+            {
+                pHeap->_hardCopy();
+
+                return &(pHeap->core->aItem[iIndex]);
+            }
+
+            iterator &operator++()
+            {
+                checkValid();
+                iIndex++;
+                if( iIndex >= pHeap->iFill )
+                    iIndex = -1;
+
+                return *this;
+            }
+
+            iterator &operator--()
+            {
+                checkValid();
+                iIndex--;
+
+                return *this;
+            }
+            
+            iterator &operator++( int )
+            {
+                checkValid();
+                iIndex++;
+                if( iIndex >= pHeap->core->iFill )
+                    iIndex = -1;
+
+                return *this;
+            }
+
+            iterator &operator--( int )
+            {
+                checkValid();
+                iIndex--;
+
+                return *this;
+            }
+
+            iterator operator+( int iDelta )
+            {
+                checkValid();
+                iterator ret( *this );
+                ret.iIndex += iDelta;
+                if( ret.iIndex >= pHeap->core->iFill )
+                    ret.iIndex = -1;
+                return ret;
+            }
+
+            iterator operator-( int iDelta )
+            {
+                checkValid();
+                iterator ret( *this );
+                ret.iIndex -= iDelta;
+                if( ret.iIndex < 0 )
+                    ret.iIndex = -1;
+                return ret;
+            }
+
+            operator bool() const
+            {
+                return iIndex != -1;
+            }
+
+            bool isValid() const
+            {
+                return iIndex != -1;
+            }
+
+            iterator &operator=( const iterator &oth )
+            {
+                pHeap = oth.pHeap;
+                iIndex = oth.iIndex;
+            }
+        };
+        
+        class const_iterator
+        {
+            friend class Heap<item, cmpfunc, itemalloc>;
+        private:
+            Heap<item, cmpfunc, itemalloc> *pHeap;
+            int iIndex;
+
+            const_iterator( Heap<item, cmpfunc, itemalloc> *pHeap,
+                    int iIndex ) :
+                pHeap( pHeap ), iIndex( iIndex )
+            {
+            }
+
+            void checkValid()
+            {
+                if( pHeap == NULL )
+                    throw Bu::ExceptionBase("Iterator not initialized.");
+                if( iIndex < 0 || iIndex >= pHeap->core->iFill )
+                    throw Bu::ExceptionBase("Iterator out of bounds.");
+            }
+
+        public:
+            const_iterator() :
+                pHeap( NULL ),
+                iIndex( -1 )
+            {
+            }
+            
+            const_iterator( const const_iterator &i ) :
+                pHeap( i.pHeap ),
+                iIndex( i.iIndex )
+            {
+            }
+            
+            const_iterator( const iterator &i ) :
+                pHeap( i.pHeap ),
+                iIndex( i.iIndex )
+            {
+            }
+
+            bool operator==( const const_iterator &oth ) const
+            {
+                return (oth.pHeap == pHeap) && (oth.iIndex == iIndex);
+            }
+
+            bool operator!=( const const_iterator &oth ) const
+            {
+                return (oth.pHeap != pHeap) || (oth.iIndex != iIndex);
+            }
+
+            const item &operator*()
+            {
+                pHeap->_hardCopy();
+
+                return pHeap->core->aItem[iIndex];
+            }
+
+            const item *operator->()
+            {
+                pHeap->_hardCopy();
+
+                return &(pHeap->core->aItem[iIndex]);
+            }
+
+            const_iterator &operator++()
+            {
+                checkValid();
+                iIndex++;
+                if( iIndex >= pHeap->core->iFill )
+                    iIndex = -1;
+
+                return *this;
+            }
+
+            const_iterator &operator--()
+            {
+                checkValid();
+                iIndex--;
+
+                return *this;
+            }
+            
+            const_iterator &operator++( int )
+            {
+                checkValid();
+                iIndex++;
+                if( iIndex >= pHeap->core->iFill )
+                    iIndex = -1;
+
+                return *this;
+            }
+
+            const_iterator &operator--( int )
+            {
+                checkValid();
+                iIndex--;
+
+                return *this;
+            }
+
+            const_iterator operator+( int iDelta )
+            {
+                checkValid();
+                const_iterator ret( *this );
+                ret.iIndex += iDelta;
+                if( ret.iIndex >= pHeap->iFill )
+                    ret.iIndex = -1;
+                return ret;
+            }
+
+            const_iterator operator-( int iDelta )
+            {
+                checkValid();
+                const_iterator ret( *this );
+                ret.iIndex -= iDelta;
+                if( ret.iIndex < 0 )
+                    ret.iIndex = -1;
+                return ret;
+            }
+
+            operator bool() const
+            {
+                return iIndex != -1;
+            }
+
+            bool isValid() const
+            {
+                return iIndex != -1;
+            }
+
+            const_iterator &operator=( const const_iterator &oth )
+            {
+                pHeap = oth.pHeap;
+                iIndex = oth.iIndex;
+            }
+
+            const_iterator &operator=( const iterator &oth )
+            {
+                pHeap = oth.pHeap;
+                iIndex = oth.iIndex;
+            }
+        };
+
+        iterator begin()
+        {
+            if( core->iFill == 0 )
+                return end();
+            return iterator( this, 0 );
+        }
+
+        const_iterator begin() const
+        {
+            if( core->iFill == 0 )
+                return end();
+            return const_iterator( this, 0 );
+        }
+
+        iterator end()
+        {
+            return iterator( this, -1 );
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator( this, -1 );
+        }
+
+
+    protected:
+        virtual Core *_copyCore( Core *src )
+        {
+            Core *pRet = _allocateCore();
+
+            pRet->iSize = src->iSize;
+            pRet->iFill = src->iFill;
+            pRet->cmp = src->cmp;
+            pRet->aItem = pRet->ia.allocate( pRet->iSize );
+            for( int j = 0; j < pRet->iFill; j++ )
+            {
+                pRet->ia.construct( &pRet->aItem[j], src->aItem[j] );
+            }
+
+            return pRet;
+        }
+    };
 };
 
 #endif
diff --git a/src/stable/hex.cpp b/src/stable/hex.cpp
index 3e6a22e..45679b5 100644
--- a/src/stable/hex.cpp
+++ b/src/stable/hex.cpp
@@ -8,11 +8,11 @@
 #include "bu/hex.h"
 
 Bu::Hex::Hex( Bu::Stream &rNext, bool bUpperCase, int iChunk ) :
-        Bu::Filter( rNext ),
-        iChunk( iChunk ),
-        iPos( 0 ),
-        iIn( 0 ),
-        sChrs(bUpperCase?"0123456789ABCDEF":"0123456789abcdef")
+    Bu::Filter( rNext ),
+    iChunk( iChunk ),
+    iPos( 0 ),
+    iIn( 0 ),
+    sChrs(bUpperCase?"0123456789ABCDEF":"0123456789abcdef")
 {
 }
 
@@ -22,48 +22,48 @@ Bu::Hex::~Hex()
 
 void Bu::Hex::start()
 {
-        iPos = iIn = 0;
+    iPos = iIn = 0;
 }
 
 Bu::size Bu::Hex::stop()
 {
-        return iPos;
+    return iPos;
 }
 
 Bu::size Bu::Hex::read( void *pBuf, Bu::size iBytes )
 {
-        Bu::size j;
-        uint8_t *puBuf = (uint8_t *)pBuf;
-        for( j = 0; j < iBytes; j++ )
-        {
-                for(; iIn < 2; iIn++ )
-                {
-                        if( rNext.read( &cIn[iIn], 1 ) == 0 )
-                                return j;
-                        if( cIn[iIn] == ' ' || cIn[iIn] == '\t' ||
-                                cIn[iIn] == '\n' || cIn[iIn] == '\r' )
-                                iIn--;
-                }
+    Bu::size j;
+    uint8_t *puBuf = (uint8_t *)pBuf;
+    for( j = 0; j < iBytes; j++ )
+    {
+        for(; iIn < 2; iIn++ )
+        {
+            if( rNext.read( &cIn[iIn], 1 ) == 0 )
+                return j;
+            if( cIn[iIn] == ' ' || cIn[iIn] == '\t' ||
+                cIn[iIn] == '\n' || cIn[iIn] == '\r' )
+                iIn--;
+        }
 #define chr2nibble( c ) ((c>='0'&&c<='9')?(c-'0'):((c|0x60)-'a'+10))
-                puBuf[j] = ((chr2nibble(cIn[0])<<4)|chr2nibble(cIn[1]));
-                iIn = 0;
-        }
-        return j;
+        puBuf[j] = ((chr2nibble(cIn[0])<<4)|chr2nibble(cIn[1]));
+        iIn = 0;
+    }
+    return j;
 }
 
 Bu::size Bu::Hex::write( const void *pBuf, Bu::size iBytes )
 {
-        char cOut[2];
-        uint8_t *puBuf = (uint8_t *)pBuf;
-        for( Bu::size j = 0; j < iBytes; j++ )
-        {
-                cOut[0] = sChrs[(puBuf[j]&0xf0)>>4];
-                cOut[1] = sChrs[(puBuf[j]&0x0f)];
-                if( iChunk > 0 && iPos%iChunk == 0 && iPos>0 )
-                        rNext.write(" ", 1 );
-                rNext.write( cOut, 2 );
-                iPos++;
-        }
-        return iBytes;
+    char cOut[2];
+    uint8_t *puBuf = (uint8_t *)pBuf;
+    for( Bu::size j = 0; j < iBytes; j++ )
+    {
+        cOut[0] = sChrs[(puBuf[j]&0xf0)>>4];
+        cOut[1] = sChrs[(puBuf[j]&0x0f)];
+        if( iChunk > 0 && iPos%iChunk == 0 && iPos>0 )
+            rNext.write(" ", 1 );
+        rNext.write( cOut, 2 );
+        iPos++;
+    }
+    return iBytes;
 }
 
diff --git a/src/stable/hex.h b/src/stable/hex.h
index a89e93d..c010173 100644
--- a/src/stable/hex.h
+++ b/src/stable/hex.h
@@ -12,46 +12,46 @@
 
 namespace Bu
 {
-        /**
-         * This very simple filter encodes to/decodes from hex encoded string data.
-         * The primary use of this filter is in debugging, use it with
-         * Bu::encodeStr to easily create hex dumps of string data, even other raw
-         * structures.
-         *
-         *@code
-         Bu::println("Hexdump: " + Bu::encodeStr<Bu::Hex>("Test data ;)") );
-         @endcode
-         * Or...
-         *@code
-         complex_struct data;
-         ...
-         Bu::println("Hexdump: " +
-                Bu::encodeStr<Bu::Hex>(
-                        Bu::String( &data, sizeof(data) )
-                        )
-                );
-         @endcode
-         **/
-        class Hex : public Bu::Filter
-        {
-        public:
-                Hex( Bu::Stream &rNext, bool bUpperCase=false, int iChunk=-1 );
-                virtual ~Hex();
+    /**
+     * This very simple filter encodes to/decodes from hex encoded string data.
+     * The primary use of this filter is in debugging, use it with
+     * Bu::encodeStr to easily create hex dumps of string data, even other raw
+     * structures.
+     *
+     *@code
+     Bu::println("Hexdump: " + Bu::encodeStr<Bu::Hex>("Test data ;)") );
+     @endcode
+     * Or...
+     *@code
+     complex_struct data;
+     ...
+     Bu::println("Hexdump: " +
+        Bu::encodeStr<Bu::Hex>(
+            Bu::String( &data, sizeof(data) )
+            )
+        );
+     @endcode
+     **/
+    class Hex : public Bu::Filter
+    {
+    public:
+        Hex( Bu::Stream &rNext, bool bUpperCase=false, int iChunk=-1 );
+        virtual ~Hex();
 
-                virtual void start();
-                virtual Bu::size stop();
+        virtual void start();
+        virtual Bu::size stop();
 
-                virtual Bu::size read( void *pBuf, Bu::size iBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size iBytes );
-                using Bu::Stream::write;
+        virtual Bu::size read( void *pBuf, Bu::size iBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size iBytes );
+        using Bu::Stream::write;
 
-        private:
-                int iChunk;
-                Bu::size iPos;
-                char cIn[2];
-                int iIn;
-                const char *sChrs;
-        };
+    private:
+        int iChunk;
+        Bu::size iPos;
+        char cIn[2];
+        int iIn;
+        const char *sChrs;
+    };
 };
 
 #endif
diff --git a/src/stable/list.h b/src/stable/list.h
index 4f9d4aa..b7fb1d1 100644
--- a/src/stable/list.h
+++ b/src/stable/list.h
@@ -16,1022 +16,1022 @@
 
 namespace Bu
 {
-        /** @cond DEVEL */
-        template<typename value>
-        struct ListLink
-        {
-                value *pValue;
-                ListLink *pNext;
-                ListLink *pPrev;
-        };
-
-        template<typename value, typename valuealloc, typename linkalloc>
-        class List;
-
-        template<typename value, typename valuealloc, typename linkalloc>
-        struct ListCore
-        {
-        friend class List<value, valuealloc, linkalloc>;
-        friend class SharedCore<
-                List<value, valuealloc, linkalloc>,
-                ListCore<value, valuealloc, linkalloc>
-                >;
-        private:
-                typedef struct ListLink<value> Link;
-                ListCore() :
-                        pFirst( NULL ),
-                        pLast( NULL ),
-                        nSize( 0 )
-                { }
-
-                virtual ~ListCore()
-                {
-                        clear();
-                }
-
-                Link *pFirst;
-                Link *pLast;
-                long nSize;
-                linkalloc la;
-                valuealloc va;
-                
-                /**
-                 * Append a value to the list.
-                 *@param v (const value_type &) The value to append.
-                 */
-                Link *append( const value &v )
-                {
-                        Link *pNew = la.allocate( 1 );
-                        pNew->pValue = va.allocate( 1 );
-                        va.construct( pNew->pValue, v );
-                        nSize++;
-                        if( pFirst == NULL )
-                        {
-                                // Empty list
-                                pFirst = pLast = pNew;
-                                pNew->pNext = pNew->pPrev = NULL;
-                        }
-                        else
-                        {
-                                pNew->pNext = NULL;
-                                pNew->pPrev = pLast;
-                                pLast->pNext = pNew;
-                                pLast = pNew;
-                        }
-                        return pNew;
-                }
-                
-                /**
-                 * Prepend a value to the list.
-                 *@param v (const value_type &) The value to prepend.
-                 */
-                Link *prepend( const value &v )
-                {
-                        Link *pNew = la.allocate( 1 );
-                        pNew->pValue = va.allocate( 1 );
-                        va.construct( pNew->pValue, v );
-                        nSize++;
-                        if( pFirst == NULL )
-                        {
-                                // Empty list
-                                pFirst = pLast = pNew;
-                                pNew->pNext = pNew->pPrev = NULL;
-                        }
-                        else
-                        {
-                                pNew->pNext = pFirst;
-                                pNew->pPrev = NULL;
-                                pFirst->pPrev = pNew;
-                                pFirst = pNew;
-                        }
-                        return pNew;
-                }
-                
-                void clear()
-                {
-                        Link *pCur = pFirst;
-                        for(;;)
-                        {
-                                if( pCur == NULL ) break;
-                                va.destroy( pCur->pValue );
-                                va.deallocate( pCur->pValue, 1 );
-                                Link *pTmp = pCur->pNext;
-                                la.destroy( pCur );
-                                la.deallocate( pCur, 1 );
-                                pCur = pTmp;
-                        }
-                        pFirst = pLast = NULL;
-                        nSize = 0;
-                }
-                
-                Link *insert( Link *pLink, const value &v )
-                {
-                        Link *pAfter = pLink;
-                        if( pAfter == NULL )
-                        {
-                                return append( v );
-                        }
-                        Link *pPrev = pAfter->pPrev;
-                        if( pPrev == NULL )
-                        {
-                                return prepend( v );
-                        }
-
-                        Link *pNew = la.allocate( 1 );
-                        pNew->pValue = va.allocate( 1 );
-                        va.construct( pNew->pValue, v );
-                        nSize++;
-                
-                        pNew->pNext = pAfter;
-                        pNew->pPrev = pPrev;
-                        pAfter->pPrev = pNew;
-                        pPrev->pNext = pNew;
-
-                        return pNew;
-                }
-
-                /**
-                 * Erase an item from the list.
-                 *@param i (iterator) The item to erase.
-                 */
-                void erase( Link *pLink )
-                {
-                        Link *pCur = pLink;
-                        if( pCur == NULL ) return;
-                        Link *pPrev = pCur->pPrev;
-                        if( pPrev == NULL )
-                        {
-                                va.destroy( pCur->pValue );
-                                va.deallocate( pCur->pValue, 1 );
-                                pFirst = pCur->pNext;
-                                la.destroy( pCur );
-                                la.deallocate( pCur, 1 );
-                                if( pFirst == NULL )
-                                        pLast = NULL;
-                                else
-                                        pFirst->pPrev = NULL;
-                                nSize--;
-                        }
-                        else
-                        {
-                                va.destroy( pCur->pValue );
-                                va.deallocate( pCur->pValue, 1 );
-                                Link *pTmp = pCur->pNext;
-                                la.destroy( pCur );
-                                la.deallocate( pCur, 1 );
-                                pPrev->pNext = pTmp;
-                                if( pTmp != NULL )
-                                        pTmp->pPrev = pPrev;
-                                else
-                                        pLast = pPrev;
-                                nSize--;
-                        }
-                }
-        };
-        /** @endcond */
-
-        /**
-         * Linked list template container.  This class is similar to the stl list
-         * class except for a few minor changes.  First, when const, all
-         * members are only accessable const.  Second, erasing a location does not
-         * invalidate the iterator used, it simply points to the next valid
-         * location, or end() if there are no more.  Other iterators pointing to
-         * the deleted record will, of course, no longer be valid.
-         *
-         *@param value (typename) The type of data to store in your list
-         *@param valuealloc (typename) Memory Allocator for your value type
-         *@param linkalloc (typename) Memory Allocator for the list links.
-         *@extends SharedCore
-         *@ingroup Containers
-         */
-        template<typename value, typename valuealloc=std::allocator<value>,
-                typename linkalloc=std::allocator<struct ListLink<value> > >
-        class List /** @cond */ : public SharedCore<
-                                 List<value, valuealloc, linkalloc>,
-                                 ListCore<value, valuealloc, linkalloc>
-                                 > /** @endcond */
-        {
-        private:
-                typedef struct ListLink<value> Link;
-                typedef class List<value, valuealloc, linkalloc> MyType;
-                typedef struct ListCore<value, valuealloc, linkalloc> Core;
-
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_allocateCore;
-
-        public:
-                struct const_iterator;
-                struct iterator;
-
-                List()
-                {
-                }
-
-                List( const MyType &src ) :
-                        SharedCore<MyType, Core >( src )
-                {
-                }
-                
-                List( const value &v )
-                {
-                        append( v );
-                }
-
-                ~List()
-                {
-                }
-
-                MyType &operator+=( const value &v )
-                {
-                        _hardCopy();
-                        append( v );
-                        return *this;
-                }
-
-                MyType &operator+=( const MyType &src )
-                {
-                        _hardCopy();
-                        append( src );
-                        return *this;
-                }
-                
-                MyType operator+( const MyType &src )
-                {
-                        MyType lNew( *this );
-                        lNew += src;
-                        return lNew;
-                }
-
-                bool operator==( const MyType &rhs ) const
-                {
-                        if( getSize() != rhs.getSize() )
-                                return false;
-
-                        for( typename MyType::const_iterator a = begin(), b = rhs.begin();
-                                 a; a++, b++ )
-                        {
-                                if( *a != *b )
-                                        return false;
-                        }
-
-                        return true;
-                }
-
-                bool operator!=( const MyType &rhs ) const
-                {
-                        return !(*this == rhs);
-                }
-
-                /**
-                 * Clear the data from the list.
-                 */
-                void clear()
-                {
-                        _hardCopy();
-                        core->clear();
-                }
-
-                MyType &enqueue( const value &v )
-                {
-                        _hardCopy();
-                        append( v );
-
-                        return *this;
-                }
-
-                value dequeue()
-                {
-                        // _hardCopy();  erase will call this for me
-                        value v = *core->pFirst->pValue;
-
-                        erase( begin() );
-
-                        return v;
-                }
-
-                MyType &push( const value &v )
-                {
-                        _hardCopy();
-                        prepend( v );
-
-                        return *this;
-                }
-
-                MyType &pop()
-                {
-                        _hardCopy();
-                        erase( begin() );
-
-                        return *this;
-                }
-
-                value peekPop()
-                {
-                        value v = first();
-                        pop();
-                        return v;
-                }
-
-                value &peek()
-                {
-                        return first();
-                }
-
-                /**
-                 * Append a value to the list.
-                 *@param v (const value_type &) The value to append.
-                 */
-                MyType &append( const value &v )
-                {
-                        _hardCopy();
-                        core->append( v );
-
-                        return *this;
-                }
-
-                MyType &append( const MyType &rSrc )
-                {
-                        _hardCopy();
-                        for( typename MyType::const_iterator i = rSrc.begin();
-                                 i != rSrc.end(); i++ )
-                        {
-                                core->append( *i );
-                        }
-
-                        return *this;
-                }
-
-                /**
-                 * Prepend a value to the list.
-                 *@param v (const value_type &) The value to prepend.
-                 */
-                MyType &prepend( const value &v )
-                {
-                        _hardCopy();
-                        core->prepend( v );
-
-                        return *this;
-                }
-
-                /**
-                 * Prepend another list to the front of this one.  This will prepend
-                 * the rSrc list in reverse order...I may fix that later.
-                 */
-                MyType &prepend( const MyType &rSrc )
-                {
-                        _hardCopy();
-                        for( typename MyType::const_iterator i = rSrc.begin();
-                                 i != rSrc.end(); i++ )
-                        {
-                                core->prepend( *i );
-                        }
-
-                        return *this;
-                }
-
-                MyType &insert( MyType::iterator &i, const value &v )
-                {
-                        _hardCopy();
-
-                        core->insert( i.pLink, v );
-
-                        return *this;
-                }
-
-                template<typename cmptype>
-                void sort( cmptype cmp )
-                {
-                        Heap<value, cmptype, valuealloc> hSort( cmp, getSize() );
-                        for( typename MyType::iterator i = begin(); i; i++ )
-                        {
-                                hSort.enqueue( *i );
-                        }
-                        clear();
-                        while( !hSort.isEmpty() )
-                        {
-                                append( hSort.dequeue() );
-                        }
-                }
-
-                void sort()
-                {
-                        sort<__basicLTCmp<value> >();
-                }
-
-                template<typename cmptype>
-                void sort()
-                {
-                        Heap<value, cmptype, valuealloc> hSort( getSize() );
-                        for( typename MyType::iterator i = begin(); i; i++ )
-                        {
-                                hSort.enqueue( *i );
-                        }
-                        clear();
-                        while( !hSort.isEmpty() )
-                        {
-                                append( hSort.dequeue() );
-                        }
-                }
-
-                /**
-                 * Insert a new item in sort order by searching for the first item that
-                 * is larger and inserting this before it, or at the end if none are
-                 * larger.  If this is the only function used to insert data in the
-                 * List all items will be sorted.  To use this, the value type must
-                 * support the > operator.
-                 */
-                template<typename cmptype>
-                iterator insertSorted( cmptype cmp, const value &v )
-                {
-                        _hardCopy();
-                        if( core->pFirst == NULL )
-                        {
-                                // Empty list
-                                return iterator( core->append( v ) );
-                        }
-                        else
-                        {
-                                Link *pCur = core->pFirst;
-                                for(;;)
-                                {
-                                        if( cmp( v, *(pCur->pValue)) )
-                                        {
-                                                return iterator( core->insert( pCur, v ) );
-                                        }
-                                        pCur = pCur->pNext;
-                                        if( pCur == NULL )
-                                        {
-                                                return iterator( core->append( v ) );
-                                        }
-                                }
-                        }
-                }
-                
-                iterator insertSorted( const value &v )
-                {
-                        return insertSorted<__basicLTCmp<value> >( v );
-                }
-
-                template<typename cmptype>
-                iterator insertSorted( const value &v )
-                {
-                        cmptype cmp;
-                        return insertSorted( cmp, v );
-                }
-
-                /**
-                 * An iterator to iterate through your list.
-                 */
-                typedef struct iterator
-                {
-                        friend struct const_iterator;
-                        friend class List<value, valuealloc, linkalloc>;
-                private:
-                        Link *pLink;
-
-                        iterator( Link *pLink ) :
-                                pLink( pLink )
-                        {
-                        }
-
-                public:
-                        iterator() :
-                                pLink( NULL )
-                        {
-                        }
-
-                        iterator( const iterator &i ) :
-                                pLink( i.pLink )
-                        {
-                        }
-
-                        /**
-                         * Equals comparison operator.
-                         *@param oth (const iterator &) The iterator to compare to.
-                         *@returns (bool) Are they equal?
-                         */
-                        bool operator==( const iterator &oth ) const
-                        {
-                                return ( pLink == oth.pLink );
-                        }
-
-                        /**
-                         * Equals comparison operator.
-                         *@param pOth (const Link *) The link to compare to.
-                         *@returns (bool) Are they equal?
-                         */
-                        bool operator==( const Link *pOth ) const
-                        {
-                                return ( pLink == pOth );
-                        }
-
-                        /**
-                         * Not equals comparison operator.
-                         *@param oth (const iterator &) The iterator to compare to.
-                         *@returns (bool) Are they not equal?
-                         */
-                        bool operator!=( const iterator &oth ) const
-                        {
-                                return ( pLink != oth.pLink );
-                        }
-
-                        /**
-                         * Not equals comparison operator.
-                         *@param pOth (const Link *) The link to compare to.
-                         *@returns (bool) Are they not equal?
-                         */
-                        bool operator!=( const Link *pOth ) const
-                        {
-                                return ( pLink != pOth );
-                        }
-
-                        /**
-                         * Dereference operator.
-                         *@returns (value_type &) The value.
-                         */
-                        value &operator*()
-                        {
-                                return *(pLink->pValue);
-                        }
-
-                        /**
-                         * Pointer access operator.
-                         *@returns (value_type *) A pointer to the value.
-                         */
-                        value *operator->()
-                        {
-                                return pLink->pValue;
-                        }
-
-                        iterator &operator++()
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past end of list.");
-                                pLink = pLink->pNext;
-                                return *this;
-                        }
-
-                        iterator &operator--()
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past begining of list.");
-                                pLink = pLink->pPrev;
-                                return *this;
-                        }
-                        
-                        iterator &operator++( int )
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past end of list.");
-                                pLink = pLink->pNext;
-                                return *this;
-                        }
-
-                        iterator &operator--( int )
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past begining of list.");
-                                pLink = pLink->pPrev;
-                                return *this;
-                        }
-
-                        iterator operator+( int iDelta )
-                        {
-                                iterator ret( *this );
-                                for( int j = 0; j < iDelta; j++ )
-                                {
-                                        if( ret.pLink == NULL )
-                                                throw Bu::ExceptionBase(
-                                                        "Attempt to iterate past begining of list.");
-                                        ret.pLink = ret.pLink->pNext;
-                                }
-                                return ret;
-                        }
-
-                        iterator operator-( int iDelta )
-                        {
-                                iterator ret( *this );
-                                for( int j = 0; j < iDelta; j++ )
-                                {
-                                        if( ret.pLink == NULL )
-                                                throw Bu::ExceptionBase(
-                                                        "Attempt to iterate past begining of list.");
-                                        ret.pLink = ret.pLink->pPrev;
-                                }
-                                return ret;
-                        }
-
-                        operator bool()
-                        {
-                                return pLink != NULL;
-                        }
-
-                        bool isValid()
-                        {
-                                return pLink != NULL;
-                        }
-
-                        /**
-                         * Assignment operator.
-                         *@param oth (const iterator &) The other iterator to set this
-                         *              one to.
-                         */
-                        iterator &operator=( const iterator &oth )
-                        {
-                                pLink = oth.pLink;
-                                return *this;
-                        }
-                } iterator;
-                
-                /**
-                 *@see iterator
-                 */
-                typedef struct const_iterator
-                {
-                        friend class List<value, valuealloc, linkalloc>;
-                private:
-                        Link *pLink;
-
-                        const_iterator( Link *pLink ) :
-                                pLink( pLink )
-                        {
-                        }
-
-                public:
-                        const_iterator() :
-                                pLink( NULL )
-                        {
-                        }
-
-                        const_iterator( const iterator &i ) :
-                                pLink( i.pLink )
-                        {
-                        }
-
-                        bool operator==( const const_iterator &oth ) const
-                        {
-                                return ( pLink == oth.pLink );
-                        }
-
-                        bool operator==( const Link *pOth ) const
-                        {
-                                return ( pLink == pOth );
-                        }
-
-                        bool operator!=( const const_iterator &oth ) const
-                        {
-                                return ( pLink != oth.pLink );
-                        }
-
-                        bool operator!=( const Link *pOth ) const
-                        {
-                                return ( pLink != pOth );
-                        }
-
-                        const value &operator*()
-                        {
-                                return *(pLink->pValue);
-                        }
-
-                        const value *operator->()
-                        {
-                                return pLink->pValue;
-                        }
-
-                        const_iterator &operator++()
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past end of list.");
-                                pLink = pLink->pNext;
-                                return *this;
-                        }
-
-                        const_iterator &operator--()
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past begining of list.");
-                                pLink = pLink->pPrev;
-                                return *this;
-                        }
-                        
-                        const_iterator &operator++( int )
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past end of list.");
-                                pLink = pLink->pNext;
-                                return *this;
-                        }
-
-                        const_iterator &operator--( int )
-                        {
-                                if( pLink == NULL )
-                                        throw Bu::ExceptionBase(
-                                                "Attempt to iterate past begining of list.");
-                                pLink = pLink->pPrev;
-                                return *this;
-                        }
-
-                        const_iterator operator+( int iDelta )
-                        {
-                                const_iterator ret( *this );
-                                for( int j = 0; j < iDelta; j++ )
-                                {
-                                        if( ret.pLink == NULL )
-                                                throw Bu::ExceptionBase(
-                                                        "Attempt to iterate past begining of list.");
-                                        ret.pLink = ret.pLink->pNext;
-                                }
-                                return ret;
-                        }
-
-                        const_iterator operator-( int iDelta )
-                        {
-                                const_iterator ret( *this );
-                                for( int j = 0; j < iDelta; j++ )
-                                {
-                                        if( ret.pLink == NULL )
-                                                throw Bu::ExceptionBase(
-                                                        "Attempt to iterate past begining of list.");
-                                        ret.pLink = ret.pLink->pPrev;
-                                }
-                                return ret;
-                        }
-
-                        const_iterator &operator=( const iterator &oth )
-                        {
-                                pLink = oth.pLink;
-                                return *this;
-                        }
-
-                        const_iterator &operator=( const const_iterator &oth )
-                        {
-                                pLink = oth.pLink;
-                                return *this;
-                        }
-
-                        operator bool()
-                        {
-                                return pLink != NULL;
-                        }
-
-                        bool isValid()
-                        {
-                                return pLink != NULL;
-                        }
-                } const_iterator;
-
-                /**
-                 * Get an iterator pointing to the first item in the list.
-                 *@returns (iterator)
-                 */
-                iterator begin()
-                {
-                        _hardCopy();
-                        return iterator( core->pFirst );
-                }
-
-                /**
-                 * Get a const iterator pointing to the first item in the list.
-                 *@returns (const const_iterator)
-                 */
-                const_iterator begin() const
-                {
-                        return const_iterator( core->pFirst );
-                }
-
-                /**
-                 * Get an iterator pointing to a place just past the last item in
-                 *              the list.
-                 *@returns (const Link *)
-                 */
-                const iterator end()
-                {
-                        return iterator( NULL );
-                }
-
-                /**
-                 * Get an iterator pointing to a place just past the last item in
-                 *              the list.
-                 *@returns (const Link *)
-                 */
-                const const_iterator end() const
-                {
-                        return const_iterator( NULL );
-                }
-
-                /**
-                 * Erase an item from the list.
-                 *@param i (iterator) The item to erase.
-                 */
-                MyType &erase( iterator i )
-                {
-                        _hardCopy();
-                        core->erase( i.pLink );
-
-                        return *this;
-                }
-
-                /**
-                 * Erase an item from the list.
-                 *@param i (iterator) The item to erase.
-                 */
-                MyType &erase( const_iterator i )
-                {
-                        _hardCopy();
-                        core->erase( i.pLink );
-
-                        return *this;
-                }
-
-                /**
-                 * Erase an item from the list if you already know the item.
-                 *@param v The item to find and erase.
-                 */
-                MyType &erase( const value &v )
-                {
-                        for( const_iterator i = begin(); i != end(); i++ )
-                        {
-                                if( (*i) == v )
-                                {
-                                        erase( i );
-                                        return *this;
-                                }
-                        }
-
-                        return *this;
-                }
-                
-                /**
-                 * Erases the first item in the list, identical to pop, but better for
-                 * lists that aren't built as stacks, since you know where it will be
-                 * erasing from.
-                 */
-                MyType &eraseFirst()
-                {
-                        _hardCopy();
-                        erase( begin() );
-
-                        return *this;
-                }
-                
-                /**
-                 * Erases the last item in the list.
-                 */
-                MyType &eraseLast()
-                {
-                        _hardCopy();
-                        core->erase( core->pLast ); 
-
-                        return *this;
-                }
-
-                iterator find( const value &v )
-                {
-                        for( iterator i = begin(); i; i++ )
-                        {
-                                if( (*i) == v )
-                                        return i;
-                        }
-
-                        return end();
-                }
-
-                const_iterator find( const value &v ) const
-                {
-                        for( const_iterator i = begin(); i; i++ )
-                        {
-                                if( (*i) == v )
-                                        return i;
-                        }
-
-                        return end();
-                }
-
-                /**
-                 * Get the current size of the list.
-                 *@returns (int) The current size of the list.
-                 */
-                long getSize() const
-                {
-                        return core->nSize;
-                }
-
-                /**
-                 * Get the first item in the list.
-                 *@returns (value_type &) The first item in the list.
-                 */
-                value &first()
-                {
-                        if( core->pFirst->pValue == NULL )
-                                throw Bu::ExceptionBase("Attempt to read first element from empty list.");
-                        _hardCopy();
-                        return *core->pFirst->pValue;
-                }
-                
-                /**
-                 * Get the first item in the list.
-                 *@returns (const value_type &) The first item in the list.
-                 */
-                const value &first() const
-                {
-                        if( core->pFirst->pValue == NULL )
-                                throw Bu::ExceptionBase("Attempt to read first element from empty list.");
-                        return *core->pFirst->pValue;
-                }
-                
-                /**
-                 * Get the last item in the list.
-                 *@returns (value_type &) The last item in the list.
-                 */
-                value &last()
-                {
-                        _hardCopy();
-                        return *core->pLast->pValue;
-                }
-                
-                /**
-                 * Get the last item in the list.
-                 *@returns (const value_type &) The last item in the list.
-                 */
-                const value &last() const
-                {
-                        return *core->pLast->pValue;
-                }
-
-                bool isEmpty() const
-                {
-                        return (core->nSize == 0);
-                }
-        
-        protected:
-                virtual Core *_copyCore( Core *src )
-                {
-                        Core *pRet = _allocateCore();
-                        for( Link *pCur = src->pFirst; pCur; pCur = pCur->pNext )
-                        {
-                                pRet->append( *pCur->pValue );
-                        }
-                        return pRet;
-                }
-
-        private:
-        };
-
-        class Formatter;
-        Formatter &operator<<( Formatter &rOut, char *sStr );
-        Formatter &operator<<( Formatter &rOut, signed char c );
-        template<typename a, typename b, typename c>
-        Formatter &operator<<( Formatter &f, const Bu::List<a,b,c> &l )
-        {
-                f << '[';
-                for( typename Bu::List<a,b,c>::const_iterator i = l.begin(); i; i++ )
-                {
-                        if( i != l.begin() )
-                                f << ", ";
-                        f << *i;
-                }
-                f << ']';
-
-                return f;
-        }
-
-        template<typename value, typename a, typename b>
-        ArchiveBase &operator<<( ArchiveBase &ar, const List<value,a,b> &h )
-        {
-                ar << h.getSize();
-                for( typename List<value>::const_iterator i = h.begin(); i != h.end(); i++ )
-                {
-                        ar << (*i);
-                }
-
-                return ar;
-        }
-
-        template<typename value, typename a, typename b>
-        ArchiveBase &operator>>( ArchiveBase &ar, List<value,a,b> &h )
-        {
-                h.clear();
-                long nSize;
-                ar >> nSize;
-
-                for( long j = 0; j < nSize; j++ )
-                {
-                        value v;
-                        ar >> v;
-                        h.append( v );
-                }
-
-                return ar;
-        }
+    /** @cond DEVEL */
+    template<typename value>
+    struct ListLink
+    {
+        value *pValue;
+        ListLink *pNext;
+        ListLink *pPrev;
+    };
+
+    template<typename value, typename valuealloc, typename linkalloc>
+    class List;
+
+    template<typename value, typename valuealloc, typename linkalloc>
+    struct ListCore
+    {
+    friend class List<value, valuealloc, linkalloc>;
+    friend class SharedCore<
+        List<value, valuealloc, linkalloc>,
+        ListCore<value, valuealloc, linkalloc>
+        >;
+    private:
+        typedef struct ListLink<value> Link;
+        ListCore() :
+            pFirst( NULL ),
+            pLast( NULL ),
+            nSize( 0 )
+        { }
+
+        virtual ~ListCore()
+        {
+            clear();
+        }
+
+        Link *pFirst;
+        Link *pLast;
+        long nSize;
+        linkalloc la;
+        valuealloc va;
+        
+        /**
+         * Append a value to the list.
+         *@param v (const value_type &) The value to append.
+         */
+        Link *append( const value &v )
+        {
+            Link *pNew = la.allocate( 1 );
+            pNew->pValue = va.allocate( 1 );
+            va.construct( pNew->pValue, v );
+            nSize++;
+            if( pFirst == NULL )
+            {
+                // Empty list
+                pFirst = pLast = pNew;
+                pNew->pNext = pNew->pPrev = NULL;
+            }
+            else
+            {
+                pNew->pNext = NULL;
+                pNew->pPrev = pLast;
+                pLast->pNext = pNew;
+                pLast = pNew;
+            }
+            return pNew;
+        }
+        
+        /**
+         * Prepend a value to the list.
+         *@param v (const value_type &) The value to prepend.
+         */
+        Link *prepend( const value &v )
+        {
+            Link *pNew = la.allocate( 1 );
+            pNew->pValue = va.allocate( 1 );
+            va.construct( pNew->pValue, v );
+            nSize++;
+            if( pFirst == NULL )
+            {
+                // Empty list
+                pFirst = pLast = pNew;
+                pNew->pNext = pNew->pPrev = NULL;
+            }
+            else
+            {
+                pNew->pNext = pFirst;
+                pNew->pPrev = NULL;
+                pFirst->pPrev = pNew;
+                pFirst = pNew;
+            }
+            return pNew;
+        }
+        
+        void clear()
+        {
+            Link *pCur = pFirst;
+            for(;;)
+            {
+                if( pCur == NULL ) break;
+                va.destroy( pCur->pValue );
+                va.deallocate( pCur->pValue, 1 );
+                Link *pTmp = pCur->pNext;
+                la.destroy( pCur );
+                la.deallocate( pCur, 1 );
+                pCur = pTmp;
+            }
+            pFirst = pLast = NULL;
+            nSize = 0;
+        }
+        
+        Link *insert( Link *pLink, const value &v )
+        {
+            Link *pAfter = pLink;
+            if( pAfter == NULL )
+            {
+                return append( v );
+            }
+            Link *pPrev = pAfter->pPrev;
+            if( pPrev == NULL )
+            {
+                return prepend( v );
+            }
+
+            Link *pNew = la.allocate( 1 );
+            pNew->pValue = va.allocate( 1 );
+            va.construct( pNew->pValue, v );
+            nSize++;
+        
+            pNew->pNext = pAfter;
+            pNew->pPrev = pPrev;
+            pAfter->pPrev = pNew;
+            pPrev->pNext = pNew;
+
+            return pNew;
+        }
+
+        /**
+         * Erase an item from the list.
+         *@param i (iterator) The item to erase.
+         */
+        void erase( Link *pLink )
+        {
+            Link *pCur = pLink;
+            if( pCur == NULL ) return;
+            Link *pPrev = pCur->pPrev;
+            if( pPrev == NULL )
+            {
+                va.destroy( pCur->pValue );
+                va.deallocate( pCur->pValue, 1 );
+                pFirst = pCur->pNext;
+                la.destroy( pCur );
+                la.deallocate( pCur, 1 );
+                if( pFirst == NULL )
+                    pLast = NULL;
+                else
+                    pFirst->pPrev = NULL;
+                nSize--;
+            }
+            else
+            {
+                va.destroy( pCur->pValue );
+                va.deallocate( pCur->pValue, 1 );
+                Link *pTmp = pCur->pNext;
+                la.destroy( pCur );
+                la.deallocate( pCur, 1 );
+                pPrev->pNext = pTmp;
+                if( pTmp != NULL )
+                    pTmp->pPrev = pPrev;
+                else
+                    pLast = pPrev;
+                nSize--;
+            }
+        }
+    };
+    /** @endcond */
+
+    /**
+     * Linked list template container.  This class is similar to the stl list
+     * class except for a few minor changes.  First, when const, all
+     * members are only accessable const.  Second, erasing a location does not
+     * invalidate the iterator used, it simply points to the next valid
+     * location, or end() if there are no more.  Other iterators pointing to
+     * the deleted record will, of course, no longer be valid.
+     *
+     *@param value (typename) The type of data to store in your list
+     *@param valuealloc (typename) Memory Allocator for your value type
+     *@param linkalloc (typename) Memory Allocator for the list links.
+     *@extends SharedCore
+     *@ingroup Containers
+     */
+    template<typename value, typename valuealloc=std::allocator<value>,
+        typename linkalloc=std::allocator<struct ListLink<value> > >
+    class List /** @cond */ : public SharedCore<
+                 List<value, valuealloc, linkalloc>,
+                 ListCore<value, valuealloc, linkalloc>
+                 > /** @endcond */
+    {
+    private:
+        typedef struct ListLink<value> Link;
+        typedef class List<value, valuealloc, linkalloc> MyType;
+        typedef struct ListCore<value, valuealloc, linkalloc> Core;
+
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_allocateCore;
+
+    public:
+        struct const_iterator;
+        struct iterator;
+
+        List()
+        {
+        }
+
+        List( const MyType &src ) :
+            SharedCore<MyType, Core >( src )
+        {
+        }
+        
+        List( const value &v )
+        {
+            append( v );
+        }
+
+        ~List()
+        {
+        }
+
+        MyType &operator+=( const value &v )
+        {
+            _hardCopy();
+            append( v );
+            return *this;
+        }
+
+        MyType &operator+=( const MyType &src )
+        {
+            _hardCopy();
+            append( src );
+            return *this;
+        }
+        
+        MyType operator+( const MyType &src )
+        {
+            MyType lNew( *this );
+            lNew += src;
+            return lNew;
+        }
+
+        bool operator==( const MyType &rhs ) const
+        {
+            if( getSize() != rhs.getSize() )
+                return false;
+
+            for( typename MyType::const_iterator a = begin(), b = rhs.begin();
+                 a; a++, b++ )
+            {
+                if( *a != *b )
+                    return false;
+            }
+
+            return true;
+        }
+
+        bool operator!=( const MyType &rhs ) const
+        {
+            return !(*this == rhs);
+        }
+
+        /**
+         * Clear the data from the list.
+         */
+        void clear()
+        {
+            _hardCopy();
+            core->clear();
+        }
+
+        MyType &enqueue( const value &v )
+        {
+            _hardCopy();
+            append( v );
+
+            return *this;
+        }
+
+        value dequeue()
+        {
+            // _hardCopy();  erase will call this for me
+            value v = *core->pFirst->pValue;
+
+            erase( begin() );
+
+            return v;
+        }
+
+        MyType &push( const value &v )
+        {
+            _hardCopy();
+            prepend( v );
+
+            return *this;
+        }
+
+        MyType &pop()
+        {
+            _hardCopy();
+            erase( begin() );
+
+            return *this;
+        }
+
+        value peekPop()
+        {
+            value v = first();
+            pop();
+            return v;
+        }
+
+        value &peek()
+        {
+            return first();
+        }
+
+        /**
+         * Append a value to the list.
+         *@param v (const value_type &) The value to append.
+         */
+        MyType &append( const value &v )
+        {
+            _hardCopy();
+            core->append( v );
+
+            return *this;
+        }
+
+        MyType &append( const MyType &rSrc )
+        {
+            _hardCopy();
+            for( typename MyType::const_iterator i = rSrc.begin();
+                 i != rSrc.end(); i++ )
+            {
+                core->append( *i );
+            }
+
+            return *this;
+        }
+
+        /**
+         * Prepend a value to the list.
+         *@param v (const value_type &) The value to prepend.
+         */
+        MyType &prepend( const value &v )
+        {
+            _hardCopy();
+            core->prepend( v );
+
+            return *this;
+        }
+
+        /**
+         * Prepend another list to the front of this one.  This will prepend
+         * the rSrc list in reverse order...I may fix that later.
+         */
+        MyType &prepend( const MyType &rSrc )
+        {
+            _hardCopy();
+            for( typename MyType::const_iterator i = rSrc.begin();
+                 i != rSrc.end(); i++ )
+            {
+                core->prepend( *i );
+            }
+
+            return *this;
+        }
+
+        MyType &insert( MyType::iterator &i, const value &v )
+        {
+            _hardCopy();
+
+            core->insert( i.pLink, v );
+
+            return *this;
+        }
+
+        template<typename cmptype>
+        void sort( cmptype cmp )
+        {
+            Heap<value, cmptype, valuealloc> hSort( cmp, getSize() );
+            for( typename MyType::iterator i = begin(); i; i++ )
+            {
+                hSort.enqueue( *i );
+            }
+            clear();
+            while( !hSort.isEmpty() )
+            {
+                append( hSort.dequeue() );
+            }
+        }
+
+        void sort()
+        {
+            sort<__basicLTCmp<value> >();
+        }
+
+        template<typename cmptype>
+        void sort()
+        {
+            Heap<value, cmptype, valuealloc> hSort( getSize() );
+            for( typename MyType::iterator i = begin(); i; i++ )
+            {
+                hSort.enqueue( *i );
+            }
+            clear();
+            while( !hSort.isEmpty() )
+            {
+                append( hSort.dequeue() );
+            }
+        }
+
+        /**
+         * Insert a new item in sort order by searching for the first item that
+         * is larger and inserting this before it, or at the end if none are
+         * larger.  If this is the only function used to insert data in the
+         * List all items will be sorted.  To use this, the value type must
+         * support the > operator.
+         */
+        template<typename cmptype>
+        iterator insertSorted( cmptype cmp, const value &v )
+        {
+            _hardCopy();
+            if( core->pFirst == NULL )
+            {
+                // Empty list
+                return iterator( core->append( v ) );
+            }
+            else
+            {
+                Link *pCur = core->pFirst;
+                for(;;)
+                {
+                    if( cmp( v, *(pCur->pValue)) )
+                    {
+                        return iterator( core->insert( pCur, v ) );
+                    }
+                    pCur = pCur->pNext;
+                    if( pCur == NULL )
+                    {
+                        return iterator( core->append( v ) );
+                    }
+                }
+            }
+        }
+        
+        iterator insertSorted( const value &v )
+        {
+            return insertSorted<__basicLTCmp<value> >( v );
+        }
+
+        template<typename cmptype>
+        iterator insertSorted( const value &v )
+        {
+            cmptype cmp;
+            return insertSorted( cmp, v );
+        }
+
+        /**
+         * An iterator to iterate through your list.
+         */
+        typedef struct iterator
+        {
+            friend struct const_iterator;
+            friend class List<value, valuealloc, linkalloc>;
+        private:
+            Link *pLink;
+
+            iterator( Link *pLink ) :
+                pLink( pLink )
+            {
+            }
+
+        public:
+            iterator() :
+                pLink( NULL )
+            {
+            }
+
+            iterator( const iterator &i ) :
+                pLink( i.pLink )
+            {
+            }
+
+            /**
+             * Equals comparison operator.
+             *@param oth (const iterator &) The iterator to compare to.
+             *@returns (bool) Are they equal?
+             */
+            bool operator==( const iterator &oth ) const
+            {
+                return ( pLink == oth.pLink );
+            }
+
+            /**
+             * Equals comparison operator.
+             *@param pOth (const Link *) The link to compare to.
+             *@returns (bool) Are they equal?
+             */
+            bool operator==( const Link *pOth ) const
+            {
+                return ( pLink == pOth );
+            }
+
+            /**
+             * Not equals comparison operator.
+             *@param oth (const iterator &) The iterator to compare to.
+             *@returns (bool) Are they not equal?
+             */
+            bool operator!=( const iterator &oth ) const
+            {
+                return ( pLink != oth.pLink );
+            }
+
+            /**
+             * Not equals comparison operator.
+             *@param pOth (const Link *) The link to compare to.
+             *@returns (bool) Are they not equal?
+             */
+            bool operator!=( const Link *pOth ) const
+            {
+                return ( pLink != pOth );
+            }
+
+            /**
+             * Dereference operator.
+             *@returns (value_type &) The value.
+             */
+            value &operator*()
+            {
+                return *(pLink->pValue);
+            }
+
+            /**
+             * Pointer access operator.
+             *@returns (value_type *) A pointer to the value.
+             */
+            value *operator->()
+            {
+                return pLink->pValue;
+            }
+
+            iterator &operator++()
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past end of list.");
+                pLink = pLink->pNext;
+                return *this;
+            }
+
+            iterator &operator--()
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past begining of list.");
+                pLink = pLink->pPrev;
+                return *this;
+            }
+            
+            iterator &operator++( int )
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past end of list.");
+                pLink = pLink->pNext;
+                return *this;
+            }
+
+            iterator &operator--( int )
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past begining of list.");
+                pLink = pLink->pPrev;
+                return *this;
+            }
+
+            iterator operator+( int iDelta )
+            {
+                iterator ret( *this );
+                for( int j = 0; j < iDelta; j++ )
+                {
+                    if( ret.pLink == NULL )
+                        throw Bu::ExceptionBase(
+                            "Attempt to iterate past begining of list.");
+                    ret.pLink = ret.pLink->pNext;
+                }
+                return ret;
+            }
+
+            iterator operator-( int iDelta )
+            {
+                iterator ret( *this );
+                for( int j = 0; j < iDelta; j++ )
+                {
+                    if( ret.pLink == NULL )
+                        throw Bu::ExceptionBase(
+                            "Attempt to iterate past begining of list.");
+                    ret.pLink = ret.pLink->pPrev;
+                }
+                return ret;
+            }
+
+            operator bool()
+            {
+                return pLink != NULL;
+            }
+
+            bool isValid()
+            {
+                return pLink != NULL;
+            }
+
+            /**
+             * Assignment operator.
+             *@param oth (const iterator &) The other iterator to set this
+             *      one to.
+             */
+            iterator &operator=( const iterator &oth )
+            {
+                pLink = oth.pLink;
+                return *this;
+            }
+        } iterator;
+        
+        /**
+         *@see iterator
+         */
+        typedef struct const_iterator
+        {
+            friend class List<value, valuealloc, linkalloc>;
+        private:
+            Link *pLink;
+
+            const_iterator( Link *pLink ) :
+                pLink( pLink )
+            {
+            }
+
+        public:
+            const_iterator() :
+                pLink( NULL )
+            {
+            }
+
+            const_iterator( const iterator &i ) :
+                pLink( i.pLink )
+            {
+            }
+
+            bool operator==( const const_iterator &oth ) const
+            {
+                return ( pLink == oth.pLink );
+            }
+
+            bool operator==( const Link *pOth ) const
+            {
+                return ( pLink == pOth );
+            }
+
+            bool operator!=( const const_iterator &oth ) const
+            {
+                return ( pLink != oth.pLink );
+            }
+
+            bool operator!=( const Link *pOth ) const
+            {
+                return ( pLink != pOth );
+            }
+
+            const value &operator*()
+            {
+                return *(pLink->pValue);
+            }
+
+            const value *operator->()
+            {
+                return pLink->pValue;
+            }
+
+            const_iterator &operator++()
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past end of list.");
+                pLink = pLink->pNext;
+                return *this;
+            }
+
+            const_iterator &operator--()
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past begining of list.");
+                pLink = pLink->pPrev;
+                return *this;
+            }
+            
+            const_iterator &operator++( int )
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past end of list.");
+                pLink = pLink->pNext;
+                return *this;
+            }
+
+            const_iterator &operator--( int )
+            {
+                if( pLink == NULL )
+                    throw Bu::ExceptionBase(
+                        "Attempt to iterate past begining of list.");
+                pLink = pLink->pPrev;
+                return *this;
+            }
+
+            const_iterator operator+( int iDelta )
+            {
+                const_iterator ret( *this );
+                for( int j = 0; j < iDelta; j++ )
+                {
+                    if( ret.pLink == NULL )
+                        throw Bu::ExceptionBase(
+                            "Attempt to iterate past begining of list.");
+                    ret.pLink = ret.pLink->pNext;
+                }
+                return ret;
+            }
+
+            const_iterator operator-( int iDelta )
+            {
+                const_iterator ret( *this );
+                for( int j = 0; j < iDelta; j++ )
+                {
+                    if( ret.pLink == NULL )
+                        throw Bu::ExceptionBase(
+                            "Attempt to iterate past begining of list.");
+                    ret.pLink = ret.pLink->pPrev;
+                }
+                return ret;
+            }
+
+            const_iterator &operator=( const iterator &oth )
+            {
+                pLink = oth.pLink;
+                return *this;
+            }
+
+            const_iterator &operator=( const const_iterator &oth )
+            {
+                pLink = oth.pLink;
+                return *this;
+            }
+
+            operator bool()
+            {
+                return pLink != NULL;
+            }
+
+            bool isValid()
+            {
+                return pLink != NULL;
+            }
+        } const_iterator;
+
+        /**
+         * Get an iterator pointing to the first item in the list.
+         *@returns (iterator)
+         */
+        iterator begin()
+        {
+            _hardCopy();
+            return iterator( core->pFirst );
+        }
+
+        /**
+         * Get a const iterator pointing to the first item in the list.
+         *@returns (const const_iterator)
+         */
+        const_iterator begin() const
+        {
+            return const_iterator( core->pFirst );
+        }
+
+        /**
+         * Get an iterator pointing to a place just past the last item in
+         *      the list.
+         *@returns (const Link *)
+         */
+        const iterator end()
+        {
+            return iterator( NULL );
+        }
+
+        /**
+         * Get an iterator pointing to a place just past the last item in
+         *      the list.
+         *@returns (const Link *)
+         */
+        const const_iterator end() const
+        {
+            return const_iterator( NULL );
+        }
+
+        /**
+         * Erase an item from the list.
+         *@param i (iterator) The item to erase.
+         */
+        MyType &erase( iterator i )
+        {
+            _hardCopy();
+            core->erase( i.pLink );
+
+            return *this;
+        }
+
+        /**
+         * Erase an item from the list.
+         *@param i (iterator) The item to erase.
+         */
+        MyType &erase( const_iterator i )
+        {
+            _hardCopy();
+            core->erase( i.pLink );
+
+            return *this;
+        }
+
+        /**
+         * Erase an item from the list if you already know the item.
+         *@param v The item to find and erase.
+         */
+        MyType &erase( const value &v )
+        {
+            for( const_iterator i = begin(); i != end(); i++ )
+            {
+                if( (*i) == v )
+                {
+                    erase( i );
+                    return *this;
+                }
+            }
+
+            return *this;
+        }
+        
+        /**
+         * Erases the first item in the list, identical to pop, but better for
+         * lists that aren't built as stacks, since you know where it will be
+         * erasing from.
+         */
+        MyType &eraseFirst()
+        {
+            _hardCopy();
+            erase( begin() );
+
+            return *this;
+        }
+        
+        /**
+         * Erases the last item in the list.
+         */
+        MyType &eraseLast()
+        {
+            _hardCopy();
+            core->erase( core->pLast ); 
+
+            return *this;
+        }
+
+        iterator find( const value &v )
+        {
+            for( iterator i = begin(); i; i++ )
+            {
+                if( (*i) == v )
+                    return i;
+            }
+
+            return end();
+        }
+
+        const_iterator find( const value &v ) const
+        {
+            for( const_iterator i = begin(); i; i++ )
+            {
+                if( (*i) == v )
+                    return i;
+            }
+
+            return end();
+        }
+
+        /**
+         * Get the current size of the list.
+         *@returns (int) The current size of the list.
+         */
+        long getSize() const
+        {
+            return core->nSize;
+        }
+
+        /**
+         * Get the first item in the list.
+         *@returns (value_type &) The first item in the list.
+         */
+        value &first()
+        {
+            if( core->pFirst->pValue == NULL )
+                throw Bu::ExceptionBase("Attempt to read first element from empty list.");
+            _hardCopy();
+            return *core->pFirst->pValue;
+        }
+        
+        /**
+         * Get the first item in the list.
+         *@returns (const value_type &) The first item in the list.
+         */
+        const value &first() const
+        {
+            if( core->pFirst->pValue == NULL )
+                throw Bu::ExceptionBase("Attempt to read first element from empty list.");
+            return *core->pFirst->pValue;
+        }
+        
+        /**
+         * Get the last item in the list.
+         *@returns (value_type &) The last item in the list.
+         */
+        value &last()
+        {
+            _hardCopy();
+            return *core->pLast->pValue;
+        }
+        
+        /**
+         * Get the last item in the list.
+         *@returns (const value_type &) The last item in the list.
+         */
+        const value &last() const
+        {
+            return *core->pLast->pValue;
+        }
+
+        bool isEmpty() const
+        {
+            return (core->nSize == 0);
+        }
+    
+    protected:
+        virtual Core *_copyCore( Core *src )
+        {
+            Core *pRet = _allocateCore();
+            for( Link *pCur = src->pFirst; pCur; pCur = pCur->pNext )
+            {
+                pRet->append( *pCur->pValue );
+            }
+            return pRet;
+        }
+
+    private:
+    };
+
+    class Formatter;
+    Formatter &operator<<( Formatter &rOut, char *sStr );
+    Formatter &operator<<( Formatter &rOut, signed char c );
+    template<typename a, typename b, typename c>
+    Formatter &operator<<( Formatter &f, const Bu::List<a,b,c> &l )
+    {
+        f << '[';
+        for( typename Bu::List<a,b,c>::const_iterator i = l.begin(); i; i++ )
+        {
+            if( i != l.begin() )
+                f << ", ";
+            f << *i;
+        }
+        f << ']';
+
+        return f;
+    }
+
+    template<typename value, typename a, typename b>
+    ArchiveBase &operator<<( ArchiveBase &ar, const List<value,a,b> &h )
+    {
+        ar << h.getSize();
+        for( typename List<value>::const_iterator i = h.begin(); i != h.end(); i++ )
+        {
+            ar << (*i);
+        }
+
+        return ar;
+    }
+
+    template<typename value, typename a, typename b>
+    ArchiveBase &operator>>( ArchiveBase &ar, List<value,a,b> &h )
+    {
+        h.clear();
+        long nSize;
+        ar >> nSize;
+
+        for( long j = 0; j < nSize; j++ )
+        {
+            value v;
+            ar >> v;
+            h.append( v );
+        }
+
+        return ar;
+    }
 
 }
 
diff --git a/src/stable/logger.cpp b/src/stable/logger.cpp
index fa0987e..7d49193 100644
--- a/src/stable/logger.cpp
+++ b/src/stable/logger.cpp
@@ -14,7 +14,7 @@
 
 Bu::Logger::Logger()
 {
-        setFormat("%t");
+    setFormat("%t");
 }
 
 Bu::Logger::~Logger()
@@ -24,186 +24,186 @@ Bu::Logger::~Logger()
 void Bu::Logger::log( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...)
 {
 #ifndef WIN32
-        if( (nLevel&nLevelMask) == 0 )
-                return;
+    if( (nLevel&nLevelMask) == 0 )
+        return;
 
-        va_list ap;
-        va_start( ap, sFormat );
-        char *text;
-        if( vasprintf( &text, sFormat, ap ) < 0 )
-        {
-                printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! WTF?\n");
-                return;
-        }
-        va_end(ap);
-        
-        time_t t = time(NULL);
-        
-        char *line = NULL;
-        struct tm *pTime;
-        pTime = localtime( &t );
-        if ( asprintf(
-                &line,
-                sLogFormat.getStr(),
-                pTime->tm_year+1900,
-                pTime->tm_mon+1,
-                pTime->tm_mday,
-                pTime->tm_hour,
-                pTime->tm_min,
-                pTime->tm_sec,
-                nLevel,
-                sFile,
-                nLine,
-                text,
-                sFunction
-                ) < 0 )
-        {
-                //printf("LOGGER: ERROR ALLOCATING STRING:  %s\n", strerror( errno ) );
-                return;
-        }
-        write( fileno(stdout), line, strlen(line) );
-        free( text );
-        free( line );
+    va_list ap;
+    va_start( ap, sFormat );
+    char *text;
+    if( vasprintf( &text, sFormat, ap ) < 0 )
+    {
+        printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! WTF?\n");
+        return;
+    }
+    va_end(ap);
+    
+    time_t t = time(NULL);
+    
+    char *line = NULL;
+    struct tm *pTime;
+    pTime = localtime( &t );
+    if ( asprintf(
+        &line,
+        sLogFormat.getStr(),
+        pTime->tm_year+1900,
+        pTime->tm_mon+1,
+        pTime->tm_mday,
+        pTime->tm_hour,
+        pTime->tm_min,
+        pTime->tm_sec,
+        nLevel,
+        sFile,
+        nLine,
+        text,
+        sFunction
+        ) < 0 )
+    {
+        //printf("LOGGER: ERROR ALLOCATING STRING:  %s\n", strerror( errno ) );
+        return;
+    }
+    write( fileno(stdout), line, strlen(line) );
+    free( text );
+    free( line );
 #else
-        #warning Bu::Logger::log IS A STUB for WIN32!!!!        
+    #warning Bu::Logger::log IS A STUB for WIN32!!!!    
 #endif
 }
 
 void Bu::Logger::setFormat( const Bu::String &str )
 {
-        sLogFormat = "";
+    sLogFormat = "";
 
-        static char fmts[][4]={
-                {'y', 'd', '0', '1'},
-                {'m', 'd', '0', '2'},
-                {'d', 'd', '0', '3'},
-                {'h', 'd', '0', '4'},
-                {'M', 'd', '0', '5'},
-                {'s', 'd', '0', '6'},
-                {'L', 'd', '0', '7'},
-                {'f', 's', '0', '8'},
-                {'l', 'd', '0', '9'},
-                {'t', 's', '1', '0'},
-                {'F', 's', '1', '1'},
-                {'\0', '\0', '\0', '\0'},
-        };
-        
-        for( const char *s = str.getStr(); *s; s++ )
-        {
-                if( *s == '%' )
-                {
-                        sLogFormat += '%';
-                        Bu::String sBuf;
-                        for(;;)
-                        {
-                                s++;
-                                int l;
-                                for( l = 0;; l++ )
-                                {
-                                        if( fmts[l][0] == '\0' )
-                                        {
-                                                sBuf += *s;
-                                                break;
-                                        }
-                                        else if( *s == fmts[l][0] )
-                                        {
-                                                sLogFormat += fmts[l][2];
-                                                sLogFormat += fmts[l][3];
-                                                sLogFormat += '$';
-                                                sLogFormat += sBuf;
-                                                sLogFormat += fmts[l][1];
-                                                break;
-                                        }
-                                }
-                                if( fmts[l][0] != '\0' )
-                                        break;
-                        }
-                }
-                else
-                {
-                        sLogFormat += *s;
-                }
-        }
-        sLogFormat += '\n';
+    static char fmts[][4]={
+        {'y', 'd', '0', '1'},
+        {'m', 'd', '0', '2'},
+        {'d', 'd', '0', '3'},
+        {'h', 'd', '0', '4'},
+        {'M', 'd', '0', '5'},
+        {'s', 'd', '0', '6'},
+        {'L', 'd', '0', '7'},
+        {'f', 's', '0', '8'},
+        {'l', 'd', '0', '9'},
+        {'t', 's', '1', '0'},
+        {'F', 's', '1', '1'},
+        {'\0', '\0', '\0', '\0'},
+    };
+    
+    for( const char *s = str.getStr(); *s; s++ )
+    {
+        if( *s == '%' )
+        {
+            sLogFormat += '%';
+            Bu::String sBuf;
+            for(;;)
+            {
+                s++;
+                int l;
+                for( l = 0;; l++ )
+                {
+                    if( fmts[l][0] == '\0' )
+                    {
+                        sBuf += *s;
+                        break;
+                    }
+                    else if( *s == fmts[l][0] )
+                    {
+                        sLogFormat += fmts[l][2];
+                        sLogFormat += fmts[l][3];
+                        sLogFormat += '$';
+                        sLogFormat += sBuf;
+                        sLogFormat += fmts[l][1];
+                        break;
+                    }
+                }
+                if( fmts[l][0] != '\0' )
+                    break;
+            }
+        }
+        else
+        {
+            sLogFormat += *s;
+        }
+    }
+    sLogFormat += '\n';
 
-        //write( fileno(stdout), sLogFormat.getStr(), sLogFormat.getSize() );
+    //write( fileno(stdout), sLogFormat.getStr(), sLogFormat.getSize() );
 }
 
 void Bu::Logger::setMask( uint32_t n )
 {
-        nLevelMask = n;
+    nLevelMask = n;
 }
 
 uint32_t Bu::Logger::getMask()
 {
-        return nLevelMask;
+    return nLevelMask;
 }
 
 void Bu::Logger::setLevel( uint32_t n )
 {
-        int j;
-        for( j = 31; j > 0; j-- )
-        {
-                if( (n&(1<<j)) )
-                {
-                        for(; j >= 0; j-- )
-                        {
-                                n |= (1<<j);
-                        }
-                        nLevelMask = n;
-                        return;
-                }
-        }
+    int j;
+    for( j = 31; j > 0; j-- )
+    {
+        if( (n&(1<<j)) )
+        {
+            for(; j >= 0; j-- )
+            {
+                n |= (1<<j);
+            }
+            nLevelMask = n;
+            return;
+        }
+    }
 }
 
 void Bu::Logger::hexDump( uint32_t nLevel, const char *sFile,
-                const char *sFunction, int nLine, const void *pDataV, long nDataLen,
-                const char *lpName )
+        const char *sFunction, int nLine, const void *pDataV, long nDataLen,
+        const char *lpName )
 {
-        if( (nLevel&nLevelMask) == 0 )
-                return;
+    if( (nLevel&nLevelMask) == 0 )
+        return;
 
-        log( nLevel, sFile, sFunction, nLine, "Displaying %ld bytes of %s.", nDataLen, lpName );
-        const unsigned char *pData = (const unsigned char *)pDataV;
-        int j = 0;
-        Bu::String sBorder;
-        for( int l = 0; l < 8*3+2*8+2+5; l++ ) sBorder += ((l!=11&&l!=37)?("-"):("+"));
-        log( nLevel, sFile, sFunction, nLine, sBorder.getStr() );
-        Bu::String sLine;
-        for(;;)
-        {
-                {
-                        char buf[16];
-                        sprintf( buf, "%010d | ", j );
-                        sLine += buf;
-                }
-                int kmax = 8;
-                if( nDataLen-j < 8 ) kmax = nDataLen-j;
-                for(int k = 0; k < 8; k++ )
-                {
-                        if( k < kmax )
-                        {
-                                char buf[4];
-                                sprintf( buf, "%02X ", (int)((unsigned char)pData[j+k]) );
-                                sLine += buf;
-                        }
-                        else
-                        {
-                                sLine += "-- ";
-                        }
-                }
-                sLine += "| ";
-                for(int k = 0; k < kmax; k++ )
-                {
-                        char buf[3];
-                        sprintf( buf, "%c", (pData[j+k]>32 && pData[j+k]<=128)?(pData[j+k]):('.') );
-                        sLine += buf;
-                }
-                log( nLevel, sFile, sFunction, nLine, sLine.getStr() );
-                sLine = "";
-                j += kmax;
-                if( j >= nDataLen ) break;
-        }
-        log( nLevel, sFile, sFunction, nLine, sBorder.getStr() );
+    log( nLevel, sFile, sFunction, nLine, "Displaying %ld bytes of %s.", nDataLen, lpName );
+    const unsigned char *pData = (const unsigned char *)pDataV;
+    int j = 0;
+    Bu::String sBorder;
+    for( int l = 0; l < 8*3+2*8+2+5; l++ ) sBorder += ((l!=11&&l!=37)?("-"):("+"));
+    log( nLevel, sFile, sFunction, nLine, sBorder.getStr() );
+    Bu::String sLine;
+    for(;;)
+    {
+        {
+            char buf[16];
+            sprintf( buf, "%010d | ", j );
+            sLine += buf;
+        }
+        int kmax = 8;
+        if( nDataLen-j < 8 ) kmax = nDataLen-j;
+        for(int k = 0; k < 8; k++ )
+        {
+            if( k < kmax )
+            {
+                char buf[4];
+                sprintf( buf, "%02X ", (int)((unsigned char)pData[j+k]) );
+                sLine += buf;
+            }
+            else
+            {
+                sLine += "-- ";
+            }
+        }
+        sLine += "| ";
+        for(int k = 0; k < kmax; k++ )
+        {
+            char buf[3];
+            sprintf( buf, "%c", (pData[j+k]>32 && pData[j+k]<=128)?(pData[j+k]):('.') );
+            sLine += buf;
+        }
+        log( nLevel, sFile, sFunction, nLine, sLine.getStr() );
+        sLine = "";
+        j += kmax;
+        if( j >= nDataLen ) break;
+    }
+    log( nLevel, sFile, sFunction, nLine, sBorder.getStr() );
 }
 
diff --git a/src/stable/logger.h b/src/stable/logger.h
index 198ffa2..bcc5a83 100644
--- a/src/stable/logger.h
+++ b/src/stable/logger.h
@@ -13,82 +13,82 @@
 
 namespace Bu
 {
-        /**
-         * Simple logging facility.  All output goes straight to stdout, unlike the
-         * old multi-log system.  Generally we expect any program complex enough to
-         * want to use this will have other facilities for processing the logging
-         * output, but if we need it we can add other output methods.
-         *
-         * Currently implemented as a singleton to avoid clutter with globals, you
-         * generally never want to use the logging system directly, it's annoying.
-         * Instead use the handy macros lineLog, setLogMask, setLogFormat, and
-         * setLogLevel.  They do all the real work for you.
-         *
-         * In the log format, you can specify extra information that will be written
-         * to the log with every message, and extras in printf style.  Use %X flags
-         * where X is one of the following:
-         * - L - Logging level of the log message (not the current mask)
-         * - y - Full year
-         * - m - Month
-         * - d - Day of month
-         * - h - Hour (24-hour format)
-         * - M - Minutes
-         * - s - Seconds 
-         * - f - Source file
-         * - l - Line number
-         * - F - function name
-         * - t - Text of message (usually important)
-         *
-         * You can include anything extra that you would like, a newline will always
-         * be added automatically, so no need to worry about that.  You can also
-         * include any extra printf style formatting that you would like, for
-         * example: "%h:%02M:%02s" for the time 4:02:09 instead of 4:2:9.
-         *
-         * It's generally handy to create an enum of values you use as levels during
-         * program execution (such as error, warning, info, debug, etc).  These
-         * levels should be treated as bitflags, and the most desirable messages,
-         * i.e. serious errors and the like should be low order (0x01), and the much
-         * less desirable messages, like debugging info, should be higher order
-         * (0xF0).  During operation you can then set either an explicit mask,
-         * selecting just the levels that you would like to see printed, or set the
-         * mask using the setLevel helper function, which simulates verbosity
-         * levels, enabling every flag lower order than the highest order set bit
-         * passed.  I.E. if you had the following enumerated levels:
-         * 
-         *@code
-         enum {
-                logError        = 0x01,
-                logWarning      = 0x02,
-                logInfo         = 0x04,
-                logDebug        = 0x08
-         };
-         @endcode
-         * And you set the mask with setMask( logInfo ) the only messages you would
-         * see are the ones catagorized logInfo.  However, if you used 
-         * setLevel( logInfo ) then you would see logInfo, logWarning, and logError
-         * type messages, since they are lower order.
-         */
-        class Logger : public Bu::Singleton<Bu::Logger>
-        {
-                friend class Bu::Singleton<Bu::Logger>;
-        private:
-                Logger();
-                virtual ~Logger();
+    /**
+     * Simple logging facility.  All output goes straight to stdout, unlike the
+     * old multi-log system.  Generally we expect any program complex enough to
+     * want to use this will have other facilities for processing the logging
+     * output, but if we need it we can add other output methods.
+     *
+     * Currently implemented as a singleton to avoid clutter with globals, you
+     * generally never want to use the logging system directly, it's annoying.
+     * Instead use the handy macros lineLog, setLogMask, setLogFormat, and
+     * setLogLevel.  They do all the real work for you.
+     *
+     * In the log format, you can specify extra information that will be written
+     * to the log with every message, and extras in printf style.  Use %X flags
+     * where X is one of the following:
+     * - L - Logging level of the log message (not the current mask)
+     * - y - Full year
+     * - m - Month
+     * - d - Day of month
+     * - h - Hour (24-hour format)
+     * - M - Minutes
+     * - s - Seconds 
+     * - f - Source file
+     * - l - Line number
+     * - F - function name
+     * - t - Text of message (usually important)
+     *
+     * You can include anything extra that you would like, a newline will always
+     * be added automatically, so no need to worry about that.  You can also
+     * include any extra printf style formatting that you would like, for
+     * example: "%h:%02M:%02s" for the time 4:02:09 instead of 4:2:9.
+     *
+     * It's generally handy to create an enum of values you use as levels during
+     * program execution (such as error, warning, info, debug, etc).  These
+     * levels should be treated as bitflags, and the most desirable messages,
+     * i.e. serious errors and the like should be low order (0x01), and the much
+     * less desirable messages, like debugging info, should be higher order
+     * (0xF0).  During operation you can then set either an explicit mask,
+     * selecting just the levels that you would like to see printed, or set the
+     * mask using the setLevel helper function, which simulates verbosity
+     * levels, enabling every flag lower order than the highest order set bit
+     * passed.  I.E. if you had the following enumerated levels:
+     * 
+     *@code
+     enum {
+        logError    = 0x01,
+        logWarning  = 0x02,
+        logInfo     = 0x04,
+        logDebug    = 0x08
+     };
+     @endcode
+     * And you set the mask with setMask( logInfo ) the only messages you would
+     * see are the ones catagorized logInfo.  However, if you used 
+     * setLevel( logInfo ) then you would see logInfo, logWarning, and logError
+     * type messages, since they are lower order.
+     */
+    class Logger : public Bu::Singleton<Bu::Logger>
+    {
+        friend class Bu::Singleton<Bu::Logger>;
+    private:
+        Logger();
+        virtual ~Logger();
 
-        public:
-                void log( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...);
+    public:
+        void log( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...);
 
-                void setFormat( const Bu::String &str );
-                void setMask( uint32_t n );
-                void setLevel( uint32_t n );
-                uint32_t getMask();
+        void setFormat( const Bu::String &str );
+        void setMask( uint32_t n );
+        void setLevel( uint32_t n );
+        uint32_t getMask();
 
-                void hexDump( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const void *pData, long nDataLen, const char *lpName );
+        void hexDump( uint32_t nLevel, const char *sFile, const char *sFunction, int nLine, const void *pData, long nDataLen, const char *lpName );
 
-        private:
-                Bu::String sLogFormat;
-                uint32_t nLevelMask;
-        };
+    private:
+        Bu::String sLogFormat;
+        uint32_t nLevelMask;
+    };
 }
 
 /**
@@ -97,29 +97,29 @@ namespace Bu
  * file, line number, and function.
  */
 #define lineLog( nLevel, sFrmt, ...) \
-        Bu::Logger::getInstance().log( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, sFrmt, ##__VA_ARGS__ ) 
+    Bu::Logger::getInstance().log( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, sFrmt, ##__VA_ARGS__ ) 
 
 #define logHexDump( nLevel, pData, iSize, sName ) \
-        Bu::Logger::getInstance().hexDump( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, pData, iSize, sName ) 
+    Bu::Logger::getInstance().hexDump( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, pData, iSize, sName ) 
 
 /**
  * Set the Bu::Logger logging mask directly.  See Bu::Logger::setMask for
  * details.
  */
 #define setLogMask( nLevel ) \
-        Bu::Logger::getInstance().setMask( nLevel ) 
+    Bu::Logger::getInstance().setMask( nLevel ) 
 
 /**
  * Set the Bu::Logger format. See Bu::Logger::setFormat for details.
  */
 #define setLogFormat( sFrmt ) \
-        Bu::Logger::getInstance().setFormat( sFrmt ) 
+    Bu::Logger::getInstance().setFormat( sFrmt ) 
 
 /**
  * Set the Bu::Logger logging mask simulating levels.  See Bu::Logger::setLevel
  * for details.
  */
 #define setLogLevel( nLevel ) \
-        Bu::Logger::getInstance().setLevel( nLevel ) 
+    Bu::Logger::getInstance().setLevel( nLevel ) 
 
 #endif
diff --git a/src/stable/lzma.cpp b/src/stable/lzma.cpp
index 9df8f57..9ec2ce0 100644
--- a/src/stable/lzma.cpp
+++ b/src/stable/lzma.cpp
@@ -15,234 +15,234 @@
 using namespace Bu;
 
 Bu::Lzma::Lzma( Bu::Stream &rNext, int nCompression, Format eFmt ) :
-        Bu::Filter( rNext ),
-        prState( NULL ),
-        nCompression( nCompression ),
-        sTotalOut( 0 ),
-        eFmt( eFmt ),
-        bEos( false )
+    Bu::Filter( rNext ),
+    prState( NULL ),
+    nCompression( nCompression ),
+    sTotalOut( 0 ),
+    eFmt( eFmt ),
+    bEos( false )
 {
-        TRACE( nCompression );
-        start();
+    TRACE( nCompression );
+    start();
 }
 
 Bu::Lzma::~Lzma()
 {
-        TRACE();
-        stop();
+    TRACE();
+    stop();
 }
 
 void Bu::Lzma::start()
 {
-        TRACE();
-        nBufSize = 64*1024;
-        pBuf = new char[nBufSize];
+    TRACE();
+    nBufSize = 64*1024;
+    pBuf = new char[nBufSize];
 }
 
 Bu::size Bu::Lzma::stop()
 {
-        TRACE();
-        if( pState )
-        {
-                if( bReading )
-                {
-                        lzma_end( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return 0;
-                }
-                else
-                {
-                        for(;;)
-                        {
-                                pState->next_in = NULL;
-                                pState->avail_in = 0;
-                                pState->avail_out = nBufSize;
-                                pState->next_out = (uint8_t *)pBuf;
-                                int res = lzma_code( pState, LZMA_FINISH );
-                                if( pState->avail_out < nBufSize )
-                                {
-                                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                                }
-                                if( res == LZMA_STREAM_END )
-                                        break;
-                        }
-                        lzma_end( pState );
-                        delete[] pBuf;
-                        pBuf = NULL;
-                        delete pState;
-                        prState = NULL;
-                        return sTotalOut;
-                }
-        }
-        return 0;
+    TRACE();
+    if( pState )
+    {
+        if( bReading )
+        {
+            lzma_end( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return 0;
+        }
+        else
+        {
+            for(;;)
+            {
+                pState->next_in = NULL;
+                pState->avail_in = 0;
+                pState->avail_out = nBufSize;
+                pState->next_out = (uint8_t *)pBuf;
+                int res = lzma_code( pState, LZMA_FINISH );
+                if( pState->avail_out < nBufSize )
+                {
+                    sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+                }
+                if( res == LZMA_STREAM_END )
+                    break;
+            }
+            lzma_end( pState );
+            delete[] pBuf;
+            pBuf = NULL;
+            delete pState;
+            prState = NULL;
+            return sTotalOut;
+        }
+    }
+    return 0;
 }
 
 void Bu::Lzma::lzmaError( int code )
 {
-        TRACE( code );
-        switch( code )
-        {
-                case LZMA_OK:
-                case LZMA_STREAM_END:
-                case LZMA_NO_CHECK:
-                case LZMA_UNSUPPORTED_CHECK:
-                        break;
+    TRACE( code );
+    switch( code )
+    {
+        case LZMA_OK:
+        case LZMA_STREAM_END:
+        case LZMA_NO_CHECK:
+        case LZMA_UNSUPPORTED_CHECK:
+            break;
 
-                case LZMA_MEM_ERROR:
-                        throw ExceptionBase("Lzma: Memory allocation error.");
+        case LZMA_MEM_ERROR:
+            throw ExceptionBase("Lzma: Memory allocation error.");
 
-                case LZMA_MEMLIMIT_ERROR:
-                        throw ExceptionBase("Lzma: Memory usage limit was reached.");
+        case LZMA_MEMLIMIT_ERROR:
+            throw ExceptionBase("Lzma: Memory usage limit was reached.");
 
-                case LZMA_FORMAT_ERROR:
-                        throw ExceptionBase("Lzma: File format not recognized.");
+        case LZMA_FORMAT_ERROR:
+            throw ExceptionBase("Lzma: File format not recognized.");
 
-                case LZMA_OPTIONS_ERROR:
-                        throw ExceptionBase("Lzma: Invalid or unsupported options.");
+        case LZMA_OPTIONS_ERROR:
+            throw ExceptionBase("Lzma: Invalid or unsupported options.");
 
-                case LZMA_DATA_ERROR:
-                        throw ExceptionBase("Lzma: Data is corrupt.");
+        case LZMA_DATA_ERROR:
+            throw ExceptionBase("Lzma: Data is corrupt.");
 
-                case LZMA_BUF_ERROR:
-                        throw ExceptionBase("Lzma: No progress is possible.");
+        case LZMA_BUF_ERROR:
+            throw ExceptionBase("Lzma: No progress is possible.");
 
-                case LZMA_PROG_ERROR:
-                        throw ExceptionBase("Lzma: Programming error.");
+        case LZMA_PROG_ERROR:
+            throw ExceptionBase("Lzma: Programming error.");
 
-                default:
-                        throw ExceptionBase("Lzma: Unknown error encountered." );
-        }
+        default:
+            throw ExceptionBase("Lzma: Unknown error encountered." );
+    }
 }
 
 Bu::size Bu::Lzma::read( void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( !pState )
-        {
-                prState = new ::lzma_stream;
-                lzma_stream zEmpty = LZMA_STREAM_INIT;
-                Bu::memcpy( prState, &zEmpty, sizeof(lzma_stream) );
-
-                bReading = true;
-                lzmaError( lzma_auto_decoder( pState, UINT64_MAX, 0 ) );
-                pState->next_in = (uint8_t *)pBuf;
-                pState->avail_in = 0;
-        }
-        if( bReading == false )
-                throw ExceptionBase("This lzma filter is in writing mode, you can't read.");
-
-        int nRead = 0;
-        int nReadTotal = pState->total_out;
-        pState->next_out = (uint8_t *)pData;
-        pState->avail_out = nBytes;
-        for(;;)
-        {
-                int ret = lzma_code( pState, LZMA_RUN );
-//              printf("inflate returned %d; avail in=%d, out=%d\n", ret,
-//                              pState->avail_in, pState->avail_out );
-        
-                nReadTotal += nRead-pState->avail_out;
-
-                if( ret == LZMA_STREAM_END )
-                {
-                        bEos = true;
-                        if( pState->avail_in > 0 )
-                        {
-                                if( rNext.isSeekable() )
-                                {
-                                        rNext.seek( -pState->avail_in );
-                                }
-                        }
-                        return nBytes-pState->avail_out;
-                }
-//              if( ret != LZMA_BUF_ERROR )
-                        lzmaError( ret );
-
-                if( pState->avail_out )
-                {
-                        if( pState->avail_in == 0 )
-                        {
-                                nRead = rNext.read( pBuf, nBufSize );
-                                if( nRead == 0 && rNext.isEos() )
-                                {
-                                        throw Bu::ExceptionBase("Premature end of underlying "
-                                                        "stream found reading deflate stream.");
-                                }
-                                pState->next_in = (uint8_t *)pBuf;
-                                pState->avail_in = nRead;
-                        }
-                }
-                else
-                {
-                        return nBytes-pState->avail_out;
-                }
-        }
-        return 0;
+    TRACE( pData, nBytes );
+    if( !pState )
+    {
+        prState = new ::lzma_stream;
+        lzma_stream zEmpty = LZMA_STREAM_INIT;
+        Bu::memcpy( prState, &zEmpty, sizeof(lzma_stream) );
+
+        bReading = true;
+        lzmaError( lzma_auto_decoder( pState, UINT64_MAX, 0 ) );
+        pState->next_in = (uint8_t *)pBuf;
+        pState->avail_in = 0;
+    }
+    if( bReading == false )
+        throw ExceptionBase("This lzma filter is in writing mode, you can't read.");
+
+    int nRead = 0;
+    int nReadTotal = pState->total_out;
+    pState->next_out = (uint8_t *)pData;
+    pState->avail_out = nBytes;
+    for(;;)
+    {
+        int ret = lzma_code( pState, LZMA_RUN );
+//      printf("inflate returned %d; avail in=%d, out=%d\n", ret,
+//              pState->avail_in, pState->avail_out );
+    
+        nReadTotal += nRead-pState->avail_out;
+
+        if( ret == LZMA_STREAM_END )
+        {
+            bEos = true;
+            if( pState->avail_in > 0 )
+            {
+                if( rNext.isSeekable() )
+                {
+                    rNext.seek( -pState->avail_in );
+                }
+            }
+            return nBytes-pState->avail_out;
+        }
+//      if( ret != LZMA_BUF_ERROR )
+            lzmaError( ret );
+
+        if( pState->avail_out )
+        {
+            if( pState->avail_in == 0 )
+            {
+                nRead = rNext.read( pBuf, nBufSize );
+                if( nRead == 0 && rNext.isEos() )
+                {
+                    throw Bu::ExceptionBase("Premature end of underlying "
+                            "stream found reading deflate stream.");
+                }
+                pState->next_in = (uint8_t *)pBuf;
+                pState->avail_in = nRead;
+            }
+        }
+        else
+        {
+            return nBytes-pState->avail_out;
+        }
+    }
+    return 0;
 }
 
 Bu::size Bu::Lzma::write( const void *pData, Bu::size nBytes )
 {
-        TRACE( pData, nBytes );
-        if( !pState )
-        {
-                prState = new ::lzma_stream;
-                lzma_stream zEmpty = LZMA_STREAM_INIT;
-                Bu::memcpy( prState, &zEmpty, sizeof(lzma_stream) );
-
-                bReading = false;
-                if( eFmt == Xz )
-                        lzmaError(
-                                lzma_easy_encoder( pState, nCompression, LZMA_CHECK_CRC64 )
-                                );
-                else if( eFmt == LzmaAlone )
-                {
-                        lzma_options_lzma opt;
-                        lzma_lzma_preset( &opt, nCompression );
-                        lzmaError( lzma_alone_encoder( pState, &opt ) );
-                }
-                else
-                        throw Bu::ExceptionBase("Invalid format for lzma.");
-        }
-        if( bReading == true )
-                throw ExceptionBase("This lzma filter is in reading mode, you can't write.");
-
-        pState->next_in = (uint8_t *)pData;
-        pState->avail_in = nBytes;
-        for(;;)
-        {
-                pState->avail_out = nBufSize;
-                pState->next_out = (uint8_t *)pBuf;
-
-                lzmaError( lzma_code( pState, LZMA_RUN ) );
-
-                if( pState->avail_out < nBufSize )
-                {
-                        sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
-                }
-                if( pState->avail_in == 0 )
-                        break;
-        }
-
-        return nBytes;
+    TRACE( pData, nBytes );
+    if( !pState )
+    {
+        prState = new ::lzma_stream;
+        lzma_stream zEmpty = LZMA_STREAM_INIT;
+        Bu::memcpy( prState, &zEmpty, sizeof(lzma_stream) );
+
+        bReading = false;
+        if( eFmt == Xz )
+            lzmaError(
+                lzma_easy_encoder( pState, nCompression, LZMA_CHECK_CRC64 )
+                );
+        else if( eFmt == LzmaAlone )
+        {
+            lzma_options_lzma opt;
+            lzma_lzma_preset( &opt, nCompression );
+            lzmaError( lzma_alone_encoder( pState, &opt ) );
+        }
+        else
+            throw Bu::ExceptionBase("Invalid format for lzma.");
+    }
+    if( bReading == true )
+        throw ExceptionBase("This lzma filter is in reading mode, you can't write.");
+
+    pState->next_in = (uint8_t *)pData;
+    pState->avail_in = nBytes;
+    for(;;)
+    {
+        pState->avail_out = nBufSize;
+        pState->next_out = (uint8_t *)pBuf;
+
+        lzmaError( lzma_code( pState, LZMA_RUN ) );
+
+        if( pState->avail_out < nBufSize )
+        {
+            sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out );
+        }
+        if( pState->avail_in == 0 )
+            break;
+    }
+
+    return nBytes;
 }
 
 bool Bu::Lzma::isOpen()
 {
-        TRACE();
-        return (pState != NULL);
+    TRACE();
+    return (pState != NULL);
 }
 
 bool Bu::Lzma::isEos()
 {
-        TRACE();
-        return bEos;
+    TRACE();
+    return bEos;
 }
 
 Bu::size Bu::Lzma::getCompressedSize()
 {
-        return sTotalOut;
+    return sTotalOut;
 }
 
diff --git a/src/stable/lzma.h b/src/stable/lzma.h
index 7118a6b..40963cc 100644
--- a/src/stable/lzma.h
+++ b/src/stable/lzma.h
@@ -14,46 +14,46 @@
 
 namespace Bu
 {
-        /**
-         * Provides XZ compression and decompression, both LZMA1 (LzmaAlone) as
-         * well as the newer LZMA2 (xz) format.  This uses .xz by default.
-         *
-         *@ingroup Streams
-         *@ingroup Compression
-         */
-        class Lzma : public Bu::Filter
-        {
-        public:
-                enum Format
-                {
-                        Xz                      = 0x01,
-                        LzmaAlone       = 0x02,
-                };
-
-                Lzma( Bu::Stream &rNext, int nCompression=6, Format eFmt=Xz );
-                virtual ~Lzma();
-
-                virtual void start();
-                virtual Bu::size stop();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-
-                virtual bool isOpen();
-                virtual bool isEos();
-
-                Bu::size getCompressedSize();
-
-        private:
-                void lzmaError( int code );
-                void *prState;
-                bool bReading;
-                int nCompression;
-                char *pBuf;
-                uint32_t nBufSize;
-                Bu::size sTotalOut;
-                Format eFmt;
-                bool bEos;
-        };
+    /**
+     * Provides XZ compression and decompression, both LZMA1 (LzmaAlone) as
+     * well as the newer LZMA2 (xz) format.  This uses .xz by default.
+     *
+     *@ingroup Streams
+     *@ingroup Compression
+     */
+    class Lzma : public Bu::Filter
+    {
+    public:
+        enum Format
+        {
+            Xz          = 0x01,
+            LzmaAlone   = 0x02,
+        };
+
+        Lzma( Bu::Stream &rNext, int nCompression=6, Format eFmt=Xz );
+        virtual ~Lzma();
+
+        virtual void start();
+        virtual Bu::size stop();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+        virtual bool isOpen();
+        virtual bool isEos();
+
+        Bu::size getCompressedSize();
+
+    private:
+        void lzmaError( int code );
+        void *prState;
+        bool bReading;
+        int nCompression;
+        char *pBuf;
+        uint32_t nBufSize;
+        Bu::size sTotalOut;
+        Format eFmt;
+        bool bEos;
+    };
 }
 
 #endif
diff --git a/src/stable/md5.cpp b/src/stable/md5.cpp
index c1d993f..e62cbf4 100644
--- a/src/stable/md5.cpp
+++ b/src/stable/md5.cpp
@@ -19,7 +19,7 @@
 
 Bu::Md5::Md5()
 {
-        reset();
+    reset();
 }
 
 Bu::Md5::~Md5()
@@ -28,15 +28,15 @@ Bu::Md5::~Md5()
 
 void Bu::Md5::reset()
 {
-        // These are the magic seed numbers...
+    // These are the magic seed numbers...
 
-        sum[0] = 0x67452301U;
-        sum[1] = 0xEFCDAB89U;
-        sum[2] = 0x98BADCFEU;
-        sum[3] = 0x10325476U;
+    sum[0] = 0x67452301U;
+    sum[1] = 0xEFCDAB89U;
+    sum[2] = 0x98BADCFEU;
+    sum[3] = 0x10325476U;
 
-        uBits[0] = 0;
-        uBits[1] = 0;
+    uBits[0] = 0;
+    uBits[1] = 0;
 }
 
 void Bu::Md5::setSalt( const Bu::String & /*sSalt*/ )
@@ -45,102 +45,102 @@ void Bu::Md5::setSalt( const Bu::String & /*sSalt*/ )
 
 void Bu::Md5::addData( const void *sVData, int iSize )
 {
-        const char *sData = (const char *)sVData;
-        uint32_t t;
-
-        t = uBits[0];
-        if( (uBits[0] = t + ((uint32_t)iSize << 3)) < t )
-                uBits[1]++;
-        uBits[1] += iSize >> 29;
-
-        t = (t >> 3) & 0x3f;    /* How many bytes we have buffered */
-
-        /* Handle any leading odd-sized chunks */
-        if( t )
-        {
-                unsigned char *p = (unsigned char *) inbuf + t;
-
-                t = 64 - t;
-                if( (uint32_t)iSize < t ) {
-                        memcpy( p, sData, iSize );
-                        return;
-                }
-                memcpy( p, sData, t );
-                toLittleEndian( inbuf, 16 );
-                compBlock( sum, (uint32_t *)inbuf );
-                sData += t;
-                iSize -= t;
-        }
-
-        /* Process data in 64-byte chunks */
-        while( iSize >= 64 )
-        {
-                memcpy( inbuf, sData, 64 );
-                toLittleEndian( inbuf, 16 );
-                compBlock( sum, (uint32_t *)inbuf );
-                sData += 64;
-                iSize -= 64;
-        }
-
-        /* Handle any remaining bytes of data. */
-        memcpy( inbuf, sData, iSize );
+    const char *sData = (const char *)sVData;
+    uint32_t t;
+
+    t = uBits[0];
+    if( (uBits[0] = t + ((uint32_t)iSize << 3)) < t )
+        uBits[1]++;
+    uBits[1] += iSize >> 29;
+
+    t = (t >> 3) & 0x3f;    /* How many bytes we have buffered */
+
+    /* Handle any leading odd-sized chunks */
+    if( t )
+    {
+        unsigned char *p = (unsigned char *) inbuf + t;
+
+        t = 64 - t;
+        if( (uint32_t)iSize < t ) {
+            memcpy( p, sData, iSize );
+            return;
+        }
+        memcpy( p, sData, t );
+        toLittleEndian( inbuf, 16 );
+        compBlock( sum, (uint32_t *)inbuf );
+        sData += t;
+        iSize -= t;
+    }
+
+    /* Process data in 64-byte chunks */
+    while( iSize >= 64 )
+    {
+        memcpy( inbuf, sData, 64 );
+        toLittleEndian( inbuf, 16 );
+        compBlock( sum, (uint32_t *)inbuf );
+        sData += 64;
+        iSize -= 64;
+    }
+
+    /* Handle any remaining bytes of data. */
+    memcpy( inbuf, sData, iSize );
 }
 
 Bu::String Bu::Md5::getResult()
 {
-        uint32_t lsum[4];
-        compCap( lsum );
-        return Bu::String( (const char *)lsum, 4*4 );
+    uint32_t lsum[4];
+    compCap( lsum );
+    return Bu::String( (const char *)lsum, 4*4 );
 }
 
 void Bu::Md5::writeResult( Bu::Stream &sOut )
 {
-        uint32_t lsum[4];
-        compCap( lsum );
-        sOut.write( lsum, 4*4 );
+    uint32_t lsum[4];
+    compCap( lsum );
+    sOut.write( lsum, 4*4 );
 }
 
 void Bu::Md5::compCap( uint32_t *sumout )
 {
-        uint8_t tmpbuf[64];
-        memcpy( sumout, sum, 4*4 );
-        memcpy( tmpbuf, inbuf, 64 );
-
-        uint32_t count;
-        uint8_t *p;
-
-        /* Compute number of bytes mod 64 */
-        count = (uBits[0] >> 3) & 0x3F;
-
-        /* Set the first char of padding to 0x80.  This is safe since there is
-           always at least one byte free */
-        p = tmpbuf + count;
-        *p++ = 0x80;
-
-        /* Bytes of padding needed to make 64 bytes */
-        count = 64 - 1 - count;
-
-        /* Pad out to 56 mod 64 */
-        if (count < 8) {
-                /* Two lots of padding:  Pad the first block to 64 bytes */
-                memset( p, 0, count );
-                toLittleEndian( tmpbuf, 16 );
-                compBlock( sumout, (uint32_t *)tmpbuf );
-
-                /* Now fill the next block with 56 bytes */
-                memset( tmpbuf, 0, 56);
-        } else {
-                /* Pad block to 56 bytes */
-                memset( p, 0, count - 8);
-        }
-        toLittleEndian( tmpbuf, 14 );
-
-        /* Append length in bits and transform */
-        ((uint32_t *) tmpbuf)[14] = uBits[0];
-        ((uint32_t *) tmpbuf)[15] = uBits[1];
-
-        compBlock( sumout, (uint32_t *)tmpbuf );
-        toLittleEndian((unsigned char *)sumout, 4);
+    uint8_t tmpbuf[64];
+    memcpy( sumout, sum, 4*4 );
+    memcpy( tmpbuf, inbuf, 64 );
+
+    uint32_t count;
+    uint8_t *p;
+
+    /* Compute number of bytes mod 64 */
+    count = (uBits[0] >> 3) & 0x3F;
+
+    /* Set the first char of padding to 0x80.  This is safe since there is
+       always at least one byte free */
+    p = tmpbuf + count;
+    *p++ = 0x80;
+
+    /* Bytes of padding needed to make 64 bytes */
+    count = 64 - 1 - count;
+
+    /* Pad out to 56 mod 64 */
+    if (count < 8) {
+        /* Two lots of padding:  Pad the first block to 64 bytes */
+        memset( p, 0, count );
+        toLittleEndian( tmpbuf, 16 );
+        compBlock( sumout, (uint32_t *)tmpbuf );
+
+        /* Now fill the next block with 56 bytes */
+        memset( tmpbuf, 0, 56);
+    } else {
+        /* Pad block to 56 bytes */
+        memset( p, 0, count - 8);
+    }
+    toLittleEndian( tmpbuf, 14 );
+
+    /* Append length in bits and transform */
+    ((uint32_t *) tmpbuf)[14] = uBits[0];
+    ((uint32_t *) tmpbuf)[15] = uBits[1];
+
+    compBlock( sumout, (uint32_t *)tmpbuf );
+    toLittleEndian((unsigned char *)sumout, 4);
 }
 
 #define F1(x, y, z) (z ^ (x & (y ^ z)))
@@ -150,15 +150,15 @@ void Bu::Md5::compCap( uint32_t *sumout )
 
 /* This is the central step in the MD5 algorithm. */
 #define MD5STEP(f, w, x, y, z, data, s) \
-        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+    ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
 
 void Bu::Md5::compBlock( uint32_t *lsum, uint32_t *x )
 {
-        register uint32_t a, b, c, d;
-        a = lsum[0];
-        b = lsum[1];
-        c = lsum[2];
-        d = lsum[3];
+    register uint32_t a, b, c, d;
+    a = lsum[0];
+    b = lsum[1];
+    c = lsum[2];
+    d = lsum[3];
 
     MD5STEP(F1, a, b, c, d, x[0] + 0xd76aa478, 7);
     MD5STEP(F1, d, a, b, c, x[1] + 0xe8c7b756, 12);
@@ -228,19 +228,19 @@ void Bu::Md5::compBlock( uint32_t *lsum, uint32_t *x )
     MD5STEP(F4, c, d, a, b, x[2] + 0x2ad7d2bb, 15);
     MD5STEP(F4, b, c, d, a, x[9] + 0xeb86d391, 21);
 
-        lsum[0] += a;
-        lsum[1] += b;
-        lsum[2] += c;
-        lsum[3] += d;
+    lsum[0] += a;
+    lsum[1] += b;
+    lsum[2] += c;
+    lsum[3] += d;
 }
 
 void Bu::Md5::_toLittleEndian( uint8_t *buf, uint32_t count )
 {
-        uint32_t t;
-        do {
-                t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
-                        ((unsigned) buf[1] << 8 | buf[0]);
-                *(uint32_t *) buf = t;
-                buf += 4;
-        } while( --count );
+    uint32_t t;
+    do {
+        t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
+            ((unsigned) buf[1] << 8 | buf[0]);
+        *(uint32_t *) buf = t;
+        buf += 4;
+    } while( --count );
 }
diff --git a/src/stable/md5.h b/src/stable/md5.h
index cb7d396..8845082 100644
--- a/src/stable/md5.h
+++ b/src/stable/md5.h
@@ -12,43 +12,43 @@
 
 namespace Bu
 {
-        /**
-         * Class for easily calculating MD5 sums of just about any data.
-         * This code is based on some public domain code written by Colin Plumb in
-         * 1993.
-         *@author Mike Buland
-         */
-        class Md5 : public Bu::CryptoHash
-        {
-        public:
-                /** Build an MD5 sum builder. */
-                Md5();
-
-                /** Deconstruct */
-                virtual ~Md5();
-
-                virtual void reset();
-                virtual void setSalt( const Bu::String &sSalt );
-                virtual void addData( const void *sData, int iSize );
-                using Bu::CryptoHash::addData;
-                virtual String getResult();
-                virtual void writeResult( Bu::Stream &sOut );
-
-        private:
-                /**
-                 * Compute one block of input data.
-                 */
-                void compBlock( uint32_t *lsum, uint32_t *x );
-                void compCap( uint32_t *sumout );
-
-                void _addData( uint8_t *target, int &iCurFill, const void *sData,
-                                int iSize );
-                void _toLittleEndian( uint8_t *buf, uint32_t count );
-                
-                uint8_t inbuf[64];
-                uint32_t sum[4];
-                uint32_t uBits[2];
-        };
+    /**
+     * Class for easily calculating MD5 sums of just about any data.
+     * This code is based on some public domain code written by Colin Plumb in
+     * 1993.
+     *@author Mike Buland
+     */
+    class Md5 : public Bu::CryptoHash
+    {
+    public:
+        /** Build an MD5 sum builder. */
+        Md5();
+
+        /** Deconstruct */
+        virtual ~Md5();
+
+        virtual void reset();
+        virtual void setSalt( const Bu::String &sSalt );
+        virtual void addData( const void *sData, int iSize );
+        using Bu::CryptoHash::addData;
+        virtual String getResult();
+        virtual void writeResult( Bu::Stream &sOut );
+
+    private:
+        /**
+         * Compute one block of input data.
+         */
+        void compBlock( uint32_t *lsum, uint32_t *x );
+        void compCap( uint32_t *sumout );
+
+        void _addData( uint8_t *target, int &iCurFill, const void *sData,
+                int iSize );
+        void _toLittleEndian( uint8_t *buf, uint32_t count );
+        
+        uint8_t inbuf[64];
+        uint32_t sum[4];
+        uint32_t uBits[2];
+    };
 };
 
 #endif
diff --git a/src/stable/membuf.cpp b/src/stable/membuf.cpp
index dea9a0e..4d6e8e6 100644
--- a/src/stable/membuf.cpp
+++ b/src/stable/membuf.cpp
@@ -10,13 +10,13 @@
 using namespace Bu;
 
 Bu::MemBuf::MemBuf() :
-        nPos( 0 )
+    nPos( 0 )
 {
 }
 
 Bu::MemBuf::MemBuf( const Bu::String &str ) :
-        sBuf( str ),
-        nPos( 0 )
+    sBuf( str ),
+    nPos( 0 )
 {
 }
 
@@ -30,76 +30,76 @@ void Bu::MemBuf::close()
 
 size Bu::MemBuf::read( void *pBuf, size nBytes )
 {
-        if( (size)sBuf.getSize()-(size)nPos < nBytes )
-                nBytes = sBuf.getSize()-nPos;
+    if( (size)sBuf.getSize()-(size)nPos < nBytes )
+        nBytes = sBuf.getSize()-nPos;
 
-        memcpy( pBuf, sBuf.getStr()+nPos, nBytes );
-        nPos += nBytes;
+    memcpy( pBuf, sBuf.getStr()+nPos, nBytes );
+    nPos += nBytes;
 
-        return nBytes;
+    return nBytes;
 }
-        
+    
 size Bu::MemBuf::write( const void *pBuf, size nBytes )
 {
-        if( nPos == sBuf.getSize() )
-        {
-                // Easiest, just append the data.
-                sBuf.append( (const char *)pBuf, nBytes );
-                nPos += nBytes;
-                return nBytes;
-        }
-        else
-        {
-                // Trickier, we must do this in two parts, overwrite, then append
-                // Frist, overwrite.
-                size iOver = sBuf.getSize() - nPos;
-                if( iOver > nBytes )
-                        iOver = nBytes;
-                memcpy( sBuf.getStr()+nPos, pBuf, iOver );
-                // Then append
-                if( iOver < nBytes )
-                {
-                        sBuf.append( ((const char *)pBuf)+iOver, nBytes-iOver );
-                }
-                nPos += nBytes;
-                return nBytes;
-        }
+    if( nPos == sBuf.getSize() )
+    {
+        // Easiest, just append the data.
+        sBuf.append( (const char *)pBuf, nBytes );
+        nPos += nBytes;
+        return nBytes;
+    }
+    else
+    {
+        // Trickier, we must do this in two parts, overwrite, then append
+        // Frist, overwrite.
+        size iOver = sBuf.getSize() - nPos;
+        if( iOver > nBytes )
+            iOver = nBytes;
+        memcpy( sBuf.getStr()+nPos, pBuf, iOver );
+        // Then append
+        if( iOver < nBytes )
+        {
+            sBuf.append( ((const char *)pBuf)+iOver, nBytes-iOver );
+        }
+        nPos += nBytes;
+        return nBytes;
+    }
 }
 
 size Bu::MemBuf::tell()
 {
-        return nPos;
+    return nPos;
 }
 
 void Bu::MemBuf::seek( size offset )
 {
-        nPos += offset;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+    nPos += offset;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
 }
 
 void Bu::MemBuf::setPos( size pos )
 {
-        nPos = pos;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+    nPos = pos;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
 }
 
 void Bu::MemBuf::setPosEnd( size pos )
 {
-        nPos = sBuf.getSize()-pos;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+    nPos = sBuf.getSize()-pos;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
 }
 
 bool Bu::MemBuf::isEos()
 {
-        return (nPos == sBuf.getSize());
+    return (nPos == sBuf.getSize());
 }
 
 bool Bu::MemBuf::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::MemBuf::flush()
@@ -108,32 +108,32 @@ void Bu::MemBuf::flush()
 
 bool Bu::MemBuf::canRead()
 {
-        return !isEos();
+    return !isEos();
 }
 
 bool Bu::MemBuf::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MemBuf::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MemBuf::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MemBuf::isSeekable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MemBuf::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::MemBuf::setBlocking( bool )
@@ -142,36 +142,36 @@ void Bu::MemBuf::setBlocking( bool )
 
 void Bu::MemBuf::setSize( size iSize )
 {
-        if( iSize < 0 )
-                iSize = 0;
-        sBuf.setSize( iSize );
-        if( nPos > iSize )
-                nPos = iSize;
+    if( iSize < 0 )
+        iSize = 0;
+    sBuf.setSize( iSize );
+    if( nPos > iSize )
+        nPos = iSize;
 }
 
 Bu::size Bu::MemBuf::getSize() const
 {
-        return sBuf.getSize();
+    return sBuf.getSize();
 }
 
 Bu::size Bu::MemBuf::getBlockSize() const
 {
-        return sBuf.getSize();
+    return sBuf.getSize();
 }
 
 Bu::String Bu::MemBuf::getLocation() const
 {
-        return "";
+    return "";
 }
 
 Bu::String &Bu::MemBuf::getString()
 {
-        return sBuf;
+    return sBuf;
 }
 
 void Bu::MemBuf::setString( const Bu::String &sNewData )
 {
-        sBuf = sNewData;
-        nPos = 0;
+    sBuf = sNewData;
+    nPos = 0;
 }
 
diff --git a/src/stable/membuf.h b/src/stable/membuf.h
index f016974..f36e0bc 100644
--- a/src/stable/membuf.h
+++ b/src/stable/membuf.h
@@ -16,53 +16,53 @@
 
 namespace Bu
 {
-        /**
-         * A memory buffer stream.  This provides a read/write stream in memory that
-         * works exactly like a file stream...only in memory.  You can seed the
-         * memory buffer with a Bu::String of your own, or start with an empty one.
-         * Due to Bu::String using Bu::SharedCore starting with a string will not
-         * necesarilly cause the MemBuf to make a copy of your memory, but if you're
-         * sure you're not going to need to change the stream then use StaticMemBuf.
-         *@ingroup Streams
-         */
-        class MemBuf : public Stream
-        {
-        public:
-                MemBuf();
-                MemBuf( const Bu::String &str );
-                virtual ~MemBuf();
+    /**
+     * A memory buffer stream.  This provides a read/write stream in memory that
+     * works exactly like a file stream...only in memory.  You can seed the
+     * memory buffer with a Bu::String of your own, or start with an empty one.
+     * Due to Bu::String using Bu::SharedCore starting with a string will not
+     * necesarilly cause the MemBuf to make a copy of your memory, but if you're
+     * sure you're not going to need to change the stream then use StaticMemBuf.
+     *@ingroup Streams
+     */
+    class MemBuf : public Stream
+    {
+    public:
+        MemBuf();
+        MemBuf( const Bu::String &str );
+        virtual ~MemBuf();
 
-                virtual void close();
-                virtual size read( void *pBuf, size iBytes );
+        virtual void close();
+        virtual size read( void *pBuf, size iBytes );
 
-                virtual size write( const void *pBuf, size iBytes );
-                using Stream::write;
-                virtual size tell();
-                virtual void seek( size offset );
-                virtual void setPos( size pos );
-                virtual void setPosEnd( size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( size iSize );
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size write( const void *pBuf, size iBytes );
+        using Stream::write;
+        virtual size tell();
+        virtual void seek( size offset );
+        virtual void setPos( size pos );
+        virtual void setPosEnd( size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( size iSize );
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-                Bu::String &getString();
-                void setString( const Bu::String &sNewData );
+        Bu::String &getString();
+        void setString( const Bu::String &sNewData );
 
-        private:
-                Bu::String sBuf;
-                size nPos;
-        };
+    private:
+        Bu::String sBuf;
+        size nPos;
+    };
 }
 
 #endif
diff --git a/src/stable/minicron.cpp b/src/stable/minicron.cpp
index 87296ae..c83cd44 100644
--- a/src/stable/minicron.cpp
+++ b/src/stable/minicron.cpp
@@ -11,260 +11,260 @@
 #include <time.h>
 
 Bu::MiniCron::MiniCron() :
-        jidNext( 1 )
+    jidNext( 1 )
 {
 }
 
 Bu::MiniCron::~MiniCron()
 {
-        while( !hJobs.isEmpty() )
-        {
-                delete hJobs.dequeue();
-        }
+    while( !hJobs.isEmpty() )
+    {
+        delete hJobs.dequeue();
+    }
 }
 
 bool Bu::MiniCron::hasJobs()
 {
-        return !hJobs.isEmpty();
+    return !hJobs.isEmpty();
 }
 
 time_t Bu::MiniCron::getNextRun()
 {
-        if( hasJobs() )
-                return hJobs.peek()->getNextRun();
-        return -1;
+    if( hasJobs() )
+        return hJobs.peek()->getNextRun();
+    return -1;
 }
 
 time_t Bu::MiniCron::getNextRun( Bu::MiniCron::JobId jid )
 {
-        for( JobHeap::iterator i = hJobs.begin(); i; i++ )
-        {
-                if( (*i)->getId() == jid )
-                {
-                        return (*i)->getNextRunTime();
-                }
-        }
-        return -1;
+    for( JobHeap::iterator i = hJobs.begin(); i; i++ )
+    {
+        if( (*i)->getId() == jid )
+        {
+            return (*i)->getNextRunTime();
+        }
+    }
+    return -1;
 }
 
 void Bu::MiniCron::poll()
 {
-        time_t tNow = time( NULL );
-
-        while( !hJobs.isEmpty() )
-        {
-                if( hJobs.peek()->getNextRun() <= tNow )
-                {
-                        Job *pJob = hJobs.dequeue();
-                        pJob->run();
-                        if( pJob->bContinue )
-                        {
-                                hJobs.enqueue( pJob );
-                        }
-                        else
-                        {
-                                delete pJob;
-                        }
-                }
-                else
-                {
-                        break;
-                }
-        }
+    time_t tNow = time( NULL );
+
+    while( !hJobs.isEmpty() )
+    {
+        if( hJobs.peek()->getNextRun() <= tNow )
+        {
+            Job *pJob = hJobs.dequeue();
+            pJob->run();
+            if( pJob->bContinue )
+            {
+                hJobs.enqueue( pJob );
+            }
+            else
+            {
+                delete pJob;
+            }
+        }
+        else
+        {
+            break;
+        }
+    }
 }
 
 Bu::MiniCron::JobId Bu::MiniCron::addJob( const Bu::String &sName,
-                Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
+        Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
 {
-        JobId jid = jidNext++;
-        Job *pJob = new Job( sName, jid );
-        pJob->sigJob = sigJob;
-        pJob->pTimer = t.clone();
-        pJob->tNextRun = pJob->pTimer->nextTime();
-        hJobs.enqueue( pJob );
+    JobId jid = jidNext++;
+    Job *pJob = new Job( sName, jid );
+    pJob->sigJob = sigJob;
+    pJob->pTimer = t.clone();
+    pJob->tNextRun = pJob->pTimer->nextTime();
+    hJobs.enqueue( pJob );
 
-        return jid;
+    return jid;
 }
 
 Bu::MiniCron::JobId Bu::MiniCron::addJobOnce( const Bu::String &sName,
-                Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
+        Bu::MiniCron::CronSignal sigJob, const Bu::MiniCron::Timer &t )
 {
-        JobId jid = jidNext++;
-        Job *pJob = new Job( sName, jid, false );
-        pJob->sigJob = sigJob;
-        pJob->pTimer = t.clone();
-        pJob->tNextRun = pJob->pTimer->nextTime();
-        hJobs.enqueue( pJob );
+    JobId jid = jidNext++;
+    Job *pJob = new Job( sName, jid, false );
+    pJob->sigJob = sigJob;
+    pJob->pTimer = t.clone();
+    pJob->tNextRun = pJob->pTimer->nextTime();
+    hJobs.enqueue( pJob );
 
-        return jid;
+    return jid;
 }
 
 void Bu::MiniCron::removeJob( JobId jid )
 {
-        Bu::List<Job *> lJobs;
-        while( !hJobs.isEmpty() )
-        {
-                Job *pJob = hJobs.dequeue();
-                if( pJob->getId() == jid )
-                {
-                        delete pJob;
-                }
-                else
-                        lJobs.append( pJob );
-        }
+    Bu::List<Job *> lJobs;
+    while( !hJobs.isEmpty() )
+    {
+        Job *pJob = hJobs.dequeue();
+        if( pJob->getId() == jid )
+        {
+            delete pJob;
+        }
+        else
+            lJobs.append( pJob );
+    }
 
-        for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
-        {
-                hJobs.enqueue( *i );
-        }
+    for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
+    {
+        hJobs.enqueue( *i );
+    }
 }
 
 void Bu::MiniCron::runJob( JobId jid, bool bReschedule )
 {
-        Bu::List<Job *> lJobs;
-        while( !hJobs.isEmpty() )
-        {
-                Job *pJob = hJobs.dequeue();
-                if( pJob->getId() == jid )
-                {
-                        pJob->run( bReschedule );
-                        if( !pJob->bContinue )
-                        {
-                                delete pJob;
-                                break;
-                        }
-                        lJobs.append( pJob );
-                        break;
-                }
-                lJobs.append( pJob );
-        }
-
-        for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
-        {
-                hJobs.enqueue( *i );
-        }
+    Bu::List<Job *> lJobs;
+    while( !hJobs.isEmpty() )
+    {
+        Job *pJob = hJobs.dequeue();
+        if( pJob->getId() == jid )
+        {
+            pJob->run( bReschedule );
+            if( !pJob->bContinue )
+            {
+                delete pJob;
+                break;
+            }
+            lJobs.append( pJob );
+            break;
+        }
+        lJobs.append( pJob );
+    }
+
+    for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
+    {
+        hJobs.enqueue( *i );
+    }
 }
 
 void Bu::MiniCron::runJob( const Bu::String &sName, bool bReschedule )
 {
-        Bu::List<Job *> lJobs;
-        while( !hJobs.isEmpty() )
-        {
-                Job *pJob = hJobs.dequeue();
-                if( pJob->getName() == sName )
-                {
-                        pJob->run( bReschedule );
-                        if( !pJob->bContinue )
-                        {
-                                delete pJob;
-                                break;
-                        }
-                        lJobs.append( pJob );
-                        break;
-                }
-                lJobs.append( pJob );
-        }
-
-        for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
-        {
-                hJobs.enqueue( *i );
-        }
+    Bu::List<Job *> lJobs;
+    while( !hJobs.isEmpty() )
+    {
+        Job *pJob = hJobs.dequeue();
+        if( pJob->getName() == sName )
+        {
+            pJob->run( bReschedule );
+            if( !pJob->bContinue )
+            {
+                delete pJob;
+                break;
+            }
+            lJobs.append( pJob );
+            break;
+        }
+        lJobs.append( pJob );
+    }
+
+    for( Bu::List<Job *>::iterator i = lJobs.begin(); i; i++ )
+    {
+        hJobs.enqueue( *i );
+    }
 }
 
 Bu::MiniCron::JobInfoList Bu::MiniCron::getJobInfo()
 {
-        JobInfoList lRet;
-        for( JobHeap::iterator i = hJobs.begin(); i; i++ )
-        {
-                lRet.append(
-                        JobInfo( (*i)->getName(), (*i)->getId(), (*i)->getNextRun() )
-                        );
-        }
-        lRet.sort();
-        return lRet;
+    JobInfoList lRet;
+    for( JobHeap::iterator i = hJobs.begin(); i; i++ )
+    {
+        lRet.append(
+            JobInfo( (*i)->getName(), (*i)->getId(), (*i)->getNextRun() )
+            );
+    }
+    lRet.sort();
+    return lRet;
 }
 
 Bu::MiniCron::Job::Job( const Bu::String &sName, JobId jid, bool bRepeat ) :
-        sName( sName ),
-        pTimer( NULL ),
-        bContinue( bRepeat ),
-        jid( jid ),
-        tAdded( time( NULL ) ),
-        iRunCount( 0 )
+    sName( sName ),
+    pTimer( NULL ),
+    bContinue( bRepeat ),
+    jid( jid ),
+    tAdded( time( NULL ) ),
+    iRunCount( 0 )
 {
 }
 
 Bu::MiniCron::Job::~Job()
 {
-        delete pTimer;
-        pTimer = NULL;
+    delete pTimer;
+    pTimer = NULL;
 }
 
 void Bu::MiniCron::Job::run( bool bReschedule )
 {
-        iRunCount++;
-        if( bReschedule )
-                tNextRun = pTimer->nextTime();
-        sigJob( *this );
+    iRunCount++;
+    if( bReschedule )
+        tNextRun = pTimer->nextTime();
+    sigJob( *this );
 }
 
 time_t Bu::MiniCron::Job::getNextRun() const
 {
-        return tNextRun;
+    return tNextRun;
 }
 
 void Bu::MiniCron::Job::calcNextRun()
 {
-        if( pTimer )
-                tNextRun = pTimer->nextTime();
+    if( pTimer )
+        tNextRun = pTimer->nextTime();
 }
 
 void Bu::MiniCron::Job::setTimer( const Timer &t )
 {
-        delete pTimer;
-        pTimer = t.clone();
+    delete pTimer;
+    pTimer = t.clone();
 }
 
 void Bu::MiniCron::Job::stop()
 {
-        bContinue = false;
+    bContinue = false;
 }
 
 void Bu::MiniCron::Job::resume()
 {
-        bContinue = true;
+    bContinue = true;
 }
 
 Bu::MiniCron::JobId Bu::MiniCron::Job::getId() const
 {
-        return jid;
+    return jid;
 }
 
 time_t Bu::MiniCron::Job::getTimeCreated() const
 {
-        return tAdded;
+    return tAdded;
 }
 
 int Bu::MiniCron::Job::getRunCount() const
 {
-        return iRunCount;
+    return iRunCount;
 }
 
 time_t Bu::MiniCron::Job::getNextRunTime() const
 {
-        return tNextRun;
+    return tNextRun;
 }
 
 Bu::String Bu::MiniCron::Job::getName() const
 {
-        return sName;
+    return sName;
 }
 
 Bu::MiniCron::JobInfo::JobInfo( const Bu::String &sName, JobId jid,
-                time_t tNext ) :
-        sName( sName ),
-        jid( jid ),
-        tNext( tNext )
+        time_t tNext ) :
+    sName( sName ),
+    jid( jid ),
+    tNext( tNext )
 {
 }
 
@@ -274,7 +274,7 @@ Bu::MiniCron::JobInfo::~JobInfo()
 
 bool Bu::MiniCron::JobInfo::operator<( const JobInfo &rhs ) const
 {
-        return jid < rhs.jid;
+    return jid < rhs.jid;
 }
 
 Bu::MiniCron::Timer::Timer()
@@ -286,8 +286,8 @@ Bu::MiniCron::Timer::~Timer()
 }
 
 Bu::MiniCron::TimerInterval::TimerInterval( time_t tFirst, time_t tInterval ) :
-        tNext( tFirst ),
-        tInterval( tInterval )
+    tNext( tFirst ),
+    tInterval( tInterval )
 {
 }
 
@@ -297,14 +297,14 @@ Bu::MiniCron::TimerInterval::~TimerInterval()
 
 time_t Bu::MiniCron::TimerInterval::nextTime()
 {
-        time_t tRet = tNext;
-        tNext += tInterval;
-        return tRet;
+    time_t tRet = tNext;
+    tNext += tInterval;
+    return tRet;
 }
 
 Bu::MiniCron::TimerBasic::TimerBasic( const Bu::String &s ) :
-        tLast( -1 ),
-        sSpec( s )
+    tLast( -1 ),
+    sSpec( s )
 {
 }
 
@@ -314,164 +314,164 @@ Bu::MiniCron::TimerBasic::~TimerBasic()
 
 time_t Bu::MiniCron::TimerBasic::nextTime()
 {
-        if( tLast == -1 )
-                tLast = time( NULL );
-
-        Bu::String::const_iterator i = sSpec.begin();
-        switch( lex( i ) )
-        {
-                case tokDaily:
-                        {
-                                int iHour = lexInt( i );
-                                int iMin = lexInt( i );
-
-                                struct tm t;
-                                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
-                                if( iHour < t.tm_hour ||
-                                        (iHour == t.tm_hour && iMin <= t.tm_min) )
-                                {
-                                        t.tm_mday++;
-                                }
-                                t.tm_hour = iHour;
-                                t.tm_min = iMin;
-                                t.tm_sec = 0;
-                                tLast = mktime( &t );
-                        }
-                        break;
-
-                case tokHourly:
-                        {
-                                int iMin = lexInt( i );
-
-                                struct tm t;
-                                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
-                                if( iMin <= t.tm_min )
-                                        t.tm_hour++;
-                                t.tm_min = iMin;
-                                t.tm_sec = 0;
-                                tLast = mktime( &t );
-                        }
-                        break;
-
-                case tokWeekly:
-                        {
-                                int iDay = lexInt( i );
-                                int iHour = lexInt( i );
-                                int iMin = lexInt( i );
-                                
-                                struct tm t;
-                                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
-                                if( iDay < t.tm_wday || 
-                                        (iDay == t.tm_wday && iHour < t.tm_hour) ||
-                                        (iDay == t.tm_wday && iHour == t.tm_hour
-                                         && iMin <= t.tm_min) )
-                                {
-                                        if( iDay <= t.tm_wday )
-                                                t.tm_mday += 7 - (t.tm_wday-iDay);
-                                        else
-                                                t.tm_mday += 7 - (iDay-t.tm_wday);
-                                }
-                                else
-                                {
-                                        t.tm_mday += (iDay-t.tm_wday);
-                                }
-                                t.tm_hour = iHour;
-                                t.tm_min = iMin;
-                                t.tm_sec = 0;
-                                tLast = mktime( &t );
-                        }
-                        break;
-
-                case tokMonthly:
-                        break;
-
-                case tokYearly:
-                        break;
-
-                default:
-                        break;
-        }
-
-        return tLast;
+    if( tLast == -1 )
+        tLast = time( NULL );
+
+    Bu::String::const_iterator i = sSpec.begin();
+    switch( lex( i ) )
+    {
+        case tokDaily:
+            {
+                int iHour = lexInt( i );
+                int iMin = lexInt( i );
+
+                struct tm t;
+                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
+                if( iHour < t.tm_hour ||
+                    (iHour == t.tm_hour && iMin <= t.tm_min) )
+                {
+                    t.tm_mday++;
+                }
+                t.tm_hour = iHour;
+                t.tm_min = iMin;
+                t.tm_sec = 0;
+                tLast = mktime( &t );
+            }
+            break;
+
+        case tokHourly:
+            {
+                int iMin = lexInt( i );
+
+                struct tm t;
+                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
+                if( iMin <= t.tm_min )
+                    t.tm_hour++;
+                t.tm_min = iMin;
+                t.tm_sec = 0;
+                tLast = mktime( &t );
+            }
+            break;
+
+        case tokWeekly:
+            {
+                int iDay = lexInt( i );
+                int iHour = lexInt( i );
+                int iMin = lexInt( i );
+                
+                struct tm t;
+                ::memcpy( &t, localtime( &tLast ), sizeof(struct tm) );
+                if( iDay < t.tm_wday || 
+                    (iDay == t.tm_wday && iHour < t.tm_hour) ||
+                    (iDay == t.tm_wday && iHour == t.tm_hour
+                     && iMin <= t.tm_min) )
+                {
+                    if( iDay <= t.tm_wday )
+                        t.tm_mday += 7 - (t.tm_wday-iDay);
+                    else
+                        t.tm_mday += 7 - (iDay-t.tm_wday);
+                }
+                else
+                {
+                    t.tm_mday += (iDay-t.tm_wday);
+                }
+                t.tm_hour = iHour;
+                t.tm_min = iMin;
+                t.tm_sec = 0;
+                tLast = mktime( &t );
+            }
+            break;
+
+        case tokMonthly:
+            break;
+
+        case tokYearly:
+            break;
+
+        default:
+            break;
+    }
+
+    return tLast;
 }
 
 Bu::MiniCron::TimerBasic::Token Bu::MiniCron::TimerBasic::lex(
-                Bu::String::const_iterator &i )
-{
-        if( !i )
-        {
-                return tokEos;
-        }
-
-        Bu::String::const_iterator b = i;
-
-        for(; b && (*b == ' ' || *b == '\t'); b++ ) { i = b+1; }
-        for(; b && *b != ' ' && *b != '\t'; b++ ) { }
-
-        Bu::String sTok( i, b );
-        i = b;
-
-        if( sTok == "daily" )
-                return tokDaily;
-        else if( sTok == "hourly" )
-                return tokHourly;
-        else if( sTok == "weekly" )
-                return tokWeekly;
-        else if( sTok == "monthly" )
-                return tokMonthly;
-        else if( sTok == "yearly" )
-                return tokYearly;
-        else if( sTok == "sun" )
-        {
-                iVal = 0;
-                return valInt;
-        }
-        else if( sTok == "mon" )
-        {
-                iVal = 1;
-                return valInt;
-        }
-        else if( sTok == "tue" )
-        {
-                iVal = 2;
-                return valInt;
-        }
-        else if( sTok == "wed" )
-        {
-                iVal = 3;
-                return valInt;
-        }
-        else if( sTok == "thu" )
-        {
-                iVal = 4;
-                return valInt;
-        }
-        else if( sTok == "fri" )
-        {
-                iVal = 5;
-                return valInt;
-        }
-        else if( sTok == "sat" )
-        {
-                iVal = 6;
-                return valInt;
-        }
-        else if( sTok[0] >= '0' && sTok[0] <= '9' )
-        {
-                iVal = strtol( sTok.getStr(), NULL, 0 );
-                return valInt;
-        }
-
-        return tokErr;
+        Bu::String::const_iterator &i )
+{
+    if( !i )
+    {
+        return tokEos;
+    }
+
+    Bu::String::const_iterator b = i;
+
+    for(; b && (*b == ' ' || *b == '\t'); b++ ) { i = b+1; }
+    for(; b && *b != ' ' && *b != '\t'; b++ ) { }
+
+    Bu::String sTok( i, b );
+    i = b;
+
+    if( sTok == "daily" )
+        return tokDaily;
+    else if( sTok == "hourly" )
+        return tokHourly;
+    else if( sTok == "weekly" )
+        return tokWeekly;
+    else if( sTok == "monthly" )
+        return tokMonthly;
+    else if( sTok == "yearly" )
+        return tokYearly;
+    else if( sTok == "sun" )
+    {
+        iVal = 0;
+        return valInt;
+    }
+    else if( sTok == "mon" )
+    {
+        iVal = 1;
+        return valInt;
+    }
+    else if( sTok == "tue" )
+    {
+        iVal = 2;
+        return valInt;
+    }
+    else if( sTok == "wed" )
+    {
+        iVal = 3;
+        return valInt;
+    }
+    else if( sTok == "thu" )
+    {
+        iVal = 4;
+        return valInt;
+    }
+    else if( sTok == "fri" )
+    {
+        iVal = 5;
+        return valInt;
+    }
+    else if( sTok == "sat" )
+    {
+        iVal = 6;
+        return valInt;
+    }
+    else if( sTok[0] >= '0' && sTok[0] <= '9' )
+    {
+        iVal = strtol( sTok.getStr(), NULL, 0 );
+        return valInt;
+    }
+
+    return tokErr;
 }
 
 int Bu::MiniCron::TimerBasic::lexInt( Bu::String::const_iterator &i )
 {
-        Token t = lex( i );
-        if( t == tokEos )
-                return 0;
-        if( t != valInt )
-                throw Bu::ExceptionBase("Expected int, got something else.");
-        return iVal;
+    Token t = lex( i );
+    if( t == tokEos )
+        return 0;
+    if( t != valInt )
+        throw Bu::ExceptionBase("Expected int, got something else.");
+    return iVal;
 }
 
diff --git a/src/stable/minicron.h b/src/stable/minicron.h
index 53e5156..953b82a 100644
--- a/src/stable/minicron.h
+++ b/src/stable/minicron.h
@@ -16,321 +16,321 @@
 
 namespace Bu
 {
-        /**
-         * A simple cron like system designed to be embedded in any program.  This
-         * class creates a simple cron system that can run any number of jobs at
-         * customizable intervals or schedules.  It does not support some of the
-         * more complex scheduling that some cron systems can do such as load
-         * balancing directly, but this could be done on the job side.
-         *
-         * This system is synchronous, it does not use any threads on it's own, but
-         * it is threadsafe, so a cron thread could be created if desired.
-         *
-         * The operation is fairly simple, jobs can be added at any time, and use
-         * any timer they would like, even custom timers.  When it is time for a
-         * job to be run it signals the slot provided when the job was added.  Every
-         * job slot recieves a handle to the job object so that it may control it's
-         * own lifetime and get information about itself.  In addition, every job
-         * is assigned a unique ID that can be used to control it's operation
-         * at any time.
-         *
-         * By default a job will continually reschedule itself after being run
-         * unless it calls stop() on it's job object, it is removed using
-         * removeJob() on the cron object, or it is added with addJobOnce.
-         *
-         *@todo A minor change to the job execution system could allow a Timer to
-         * defer or reschedule execution instead of the job executing.  This would,
-         * in effect, allow us to do every type of interesting scheduling that
-         * systems like fcron offer, including time constrained load-balanced
-         * execution.
-         */
-        class MiniCron
-        {
-        public:
-                class Job;
-                class Timer;
-                typedef Bu::Signal1<void, Bu::MiniCron::Job &> CronSignal;
-                typedef int JobId;
-
-                MiniCron();
-                virtual ~MiniCron();
-
-                /**
-                 * Tells you if there are jobs registered in the MiniCron.
-                 *@returns true if there are jobs, false otherwise.
-                 */
-                virtual bool hasJobs();
-
-                /**
-                 * If there are jobs, tells you the time the next one will execute.
-                 *@returns The timestamp that the next job will execute at.
-                 */
-                virtual time_t getNextRun();
-                
-                /**
-                 * Tells you the time the job matching jid will run next.
-                 *@returns The timestamp that the job jid will next run.
-                 */
-                virtual time_t getNextRun( JobId jid );
-
-                /**
-                 * Call this regularly to execute all jobs that should be executed.
-                 * This will loop until all jobs who's run time match the current time
-                 * or are below the current time (we've missed them).
-                 * If there is nothing to run, the runtime of this funcion is constant,
-                 * it is very fast.  Otherwise it executes at log(N) per job run,
-                 * O(N*log(N)).
-                 */
-                virtual void poll();
-
-                /**
-                 * Add a job for repeated scheduling.  Pass in a slot to signal, and a
-                 * Timer object to use to do the scheduling.  This function returns a
-                 * JobId which can be used at a later time to control the execution of
-                 * the job.
-                 */
-                virtual JobId addJob( const Bu::String &sName, CronSignal sigJob,
-                                const Timer &t );
-
-                /**
-                 * Add a job for one time scheduling.  Pass in a slot to signal, and a
-                 * Timer object to use to schodule the one run of this job.  This
-                 * function returns a JobId which can be used at a later time to control
-                 * the execution of the job.
-                 */
-                virtual JobId addJobOnce( const Bu::String &sName, CronSignal sigJob,
-                                const Timer &t );
-
-                /**
-                 * Remove a job, preventing all future runs of the job.  If there is no
-                 * job matching the given JobId then nothing will happen.  However, this
-                 * function is relatively expensive compared to the others in this class
-                 * and has a worse case runtime of 2*N*log(N), still not that bad, and
-                 * a O(N*log(N)).
-                 */
-                virtual void removeJob( JobId jid );
-
-                /**
-                 * Executes the job specified right now.  If bReschedule is true then
-                 * the job is then removed from the queue and rescheduled as though
-                 * it's time had come naturally to be run.  Otherwise, it's run without
-                 * interrupting the normal schedule.
-                 */
-                virtual void runJob( JobId jid, bool bReschedule=false );
-
-                /**
-                 * Executes the job specified right now.  If bReschedule is true then
-                 * the job is then removed from the queue and rescheduled as though
-                 * it's time had come naturally to be run.  Otherwise, it's run without
-                 * interrupting the normal schedule.
-                 */
-                virtual void runJob( const Bu::String &sName, bool bReschedule=false );
-
-                class JobInfo
-                {
-                public:
-                        JobInfo( const Bu::String &sName, JobId jid, time_t tNext );
-                        virtual ~JobInfo();
-                        
-                        bool operator<( const JobInfo &rhs ) const;
-
-                        Bu::String sName;
-                        JobId jid;
-                        time_t tNext;
-                };
-                typedef Bu::List<JobInfo> JobInfoList;
-
-                JobInfoList getJobInfo();
-
-                /**
-                 * The baseclass for timer/schedulers for MiniCron jobs.  Classes that
-                 * inherit from this are used to determine when jobs will run and at
-                 * what interval.
-                 */
-                class Timer
-                {
-                public:
-                        Timer();
-                        virtual ~Timer();
-
-                        /**
-                         * Called by MiniCron when each job is run to determine the next
-                         * time that a job should be run.  When a job is run, this function
-                         * is actually called before the job is executed again so that the
-                         * job can tell when the next time it will be run will be.
-                         */
-                        virtual time_t nextTime()=0;
-
-                        /**
-                         * This function should return a copy of the child class.
-                         */
-                        virtual Timer *clone() const = 0;
-                };
-
-                /**
-                 * Execute the job every tInterval seconds, also you can delay the
-                 * first run by a different amount of time from the job's creation.
-                 */
-                class TimerInterval : public Timer
-                {
-                public:
-                        TimerInterval( time_t tFirst, time_t tInterval );
-                        virtual ~TimerInterval();
-
-                        virtual time_t nextTime();
-                        virtual Timer *clone() const
-                                { return new TimerInterval( *this ); }
-                private:
-                        time_t tNext;
-                        time_t tInterval;
-                };
-
-                /**
-                 * A much more general timer class that can be used for much more
-                 * "cron-like" functionality.  The constructor takes a string that
-                 * describes the times that the job should be run.  At the moment the
-                 * following schemes are understood:
-                 *
-                 * "daily [hour] [minute]"
-                 * "hourly [minute]"
-                 * "weekly [day] [hour] [minute]"
-                 *
-                 * In these examples each word in [brackets] represents a number that
-                 * matches the data type in the brackets.  [day] is the number of days
-                 * since sunday, 0-6.  You can also use lowercase three character
-                 * abbreviations for the day names.
-                 *
-                 * Many more forms follow.
-                 */
-                class TimerBasic : public Timer
-                {
-                public:
-                        TimerBasic( const Bu::String &s );
-                        virtual ~TimerBasic();
-
-                        virtual time_t nextTime();
-                        virtual Timer *clone() const
-                                { return new TimerBasic( *this ); }
-
-                private:
-                        enum Token
-                        {
-                                tokDaily,
-                                tokHourly,
-                                tokWeekly,
-                                tokMonthly,
-                                tokYearly,
-                                valInt,
-                                tokErr,
-                                tokEos
-                        };
-                        Token lex( Bu::String::const_iterator &i );
-                        int lexInt( Bu::String::const_iterator &i );
-                        int iVal; //< A temp variable for parsing.
-                        time_t tLast;
-                        Bu::String sSpec;
-                };
-                
-                /**
-                 * Represents a MiniCron Job.  This class is used for both internal
-                 * job management as well as job slot interaction and control.  Objects
-                 * of this class are passed into the slots that are signaled when a job
-                 * is executed.
-                 */
-                class Job
-                {
-                        friend class Bu::MiniCron;
-                private:
-                        Job( const Bu::String &sName, JobId jid, bool bRepeat=true );
-                        virtual ~Job();
-
-                public:
-
-                        /**
-                         * Execute this job once, increment the runcount and schedule the
-                         * next occurance of it.
-                         */
-                        void run( bool bReschedule=true );
-
-                        /**
-                         * Get the time this job will next run.
-                         */
-                        time_t getNextRun() const;
-
-                        /**
-                         * Compute the time this job will next run.
-                         */
-                        void calcNextRun();
-
-                        /**
-                         * Replace the current job timer with a new one, this will trigger
-                         * a re-schedule.
-                         */
-                        void setTimer( const Timer &t );
-
-                        /**
-                         * Stop execution of this job, never execute this job again.
-                         */
-                        void stop();
-
-                        /**
-                         * Undo a previous stop.  This will cause a job that has been
-                         * stopped or even added with addJobOnce to be set for repeated
-                         * scheduling.
-                         */
-                        void resume();
-
-                        /**
-                         * Get the unique ID of this job.
-                         */
-                        JobId getId() const;
-
-                        /**
-                         * Get the timestamp this job was created.
-                         */
-                        time_t getTimeCreated() const;
-
-                        /**
-                         * Get the current run count of this job, how many times it has been
-                         * executed.  This is incremented before the slot is signaled.
-                         */
-                        int getRunCount() const;
-
-                        /**
-                         * Get the next time that this job will be run.  Certain timers may
-                         * have the ability to delay job executions, so this is the earliest
-                         * time that the job may run.
-                         */
-                        time_t getNextRunTime() const;
-
-                        /**
-                         * Gets the name that was set when the job was created.
-                         */
-                        Bu::String getName() const;
-
-                private:
-                        Bu::String sName;
-                        CronSignal sigJob;
-                        time_t tNextRun;
-                        Timer *pTimer;
-                        bool bContinue;
-                        JobId jid;
-                        time_t tAdded;
-                        int iRunCount;
-                };
-
-        private:
-                struct JobPtrCmp
-                {
-                        bool operator()( const Job *pLeft, const Job *pRight )
-                        {
-                                return pLeft->tNextRun < pRight->tNextRun;
-                        }
-                };
-                typedef Bu::Heap<Job *, JobPtrCmp> JobHeap;
-                JobHeap hJobs;
-                JobId jidNext;
-        };
+    /**
+     * A simple cron like system designed to be embedded in any program.  This
+     * class creates a simple cron system that can run any number of jobs at
+     * customizable intervals or schedules.  It does not support some of the
+     * more complex scheduling that some cron systems can do such as load
+     * balancing directly, but this could be done on the job side.
+     *
+     * This system is synchronous, it does not use any threads on it's own, but
+     * it is threadsafe, so a cron thread could be created if desired.
+     *
+     * The operation is fairly simple, jobs can be added at any time, and use
+     * any timer they would like, even custom timers.  When it is time for a
+     * job to be run it signals the slot provided when the job was added.  Every
+     * job slot recieves a handle to the job object so that it may control it's
+     * own lifetime and get information about itself.  In addition, every job
+     * is assigned a unique ID that can be used to control it's operation
+     * at any time.
+     *
+     * By default a job will continually reschedule itself after being run
+     * unless it calls stop() on it's job object, it is removed using
+     * removeJob() on the cron object, or it is added with addJobOnce.
+     *
+     *@todo A minor change to the job execution system could allow a Timer to
+     * defer or reschedule execution instead of the job executing.  This would,
+     * in effect, allow us to do every type of interesting scheduling that
+     * systems like fcron offer, including time constrained load-balanced
+     * execution.
+     */
+    class MiniCron
+    {
+    public:
+        class Job;
+        class Timer;
+        typedef Bu::Signal1<void, Bu::MiniCron::Job &> CronSignal;
+        typedef int JobId;
+
+        MiniCron();
+        virtual ~MiniCron();
+
+        /**
+         * Tells you if there are jobs registered in the MiniCron.
+         *@returns true if there are jobs, false otherwise.
+         */
+        virtual bool hasJobs();
+
+        /**
+         * If there are jobs, tells you the time the next one will execute.
+         *@returns The timestamp that the next job will execute at.
+         */
+        virtual time_t getNextRun();
+        
+        /**
+         * Tells you the time the job matching jid will run next.
+         *@returns The timestamp that the job jid will next run.
+         */
+        virtual time_t getNextRun( JobId jid );
+
+        /**
+         * Call this regularly to execute all jobs that should be executed.
+         * This will loop until all jobs who's run time match the current time
+         * or are below the current time (we've missed them).
+         * If there is nothing to run, the runtime of this funcion is constant,
+         * it is very fast.  Otherwise it executes at log(N) per job run,
+         * O(N*log(N)).
+         */
+        virtual void poll();
+
+        /**
+         * Add a job for repeated scheduling.  Pass in a slot to signal, and a
+         * Timer object to use to do the scheduling.  This function returns a
+         * JobId which can be used at a later time to control the execution of
+         * the job.
+         */
+        virtual JobId addJob( const Bu::String &sName, CronSignal sigJob,
+                const Timer &t );
+
+        /**
+         * Add a job for one time scheduling.  Pass in a slot to signal, and a
+         * Timer object to use to schodule the one run of this job.  This
+         * function returns a JobId which can be used at a later time to control
+         * the execution of the job.
+         */
+        virtual JobId addJobOnce( const Bu::String &sName, CronSignal sigJob,
+                const Timer &t );
+
+        /**
+         * Remove a job, preventing all future runs of the job.  If there is no
+         * job matching the given JobId then nothing will happen.  However, this
+         * function is relatively expensive compared to the others in this class
+         * and has a worse case runtime of 2*N*log(N), still not that bad, and
+         * a O(N*log(N)).
+         */
+        virtual void removeJob( JobId jid );
+
+        /**
+         * Executes the job specified right now.  If bReschedule is true then
+         * the job is then removed from the queue and rescheduled as though
+         * it's time had come naturally to be run.  Otherwise, it's run without
+         * interrupting the normal schedule.
+         */
+        virtual void runJob( JobId jid, bool bReschedule=false );
+
+        /**
+         * Executes the job specified right now.  If bReschedule is true then
+         * the job is then removed from the queue and rescheduled as though
+         * it's time had come naturally to be run.  Otherwise, it's run without
+         * interrupting the normal schedule.
+         */
+        virtual void runJob( const Bu::String &sName, bool bReschedule=false );
+
+        class JobInfo
+        {
+        public:
+            JobInfo( const Bu::String &sName, JobId jid, time_t tNext );
+            virtual ~JobInfo();
+            
+            bool operator<( const JobInfo &rhs ) const;
+
+            Bu::String sName;
+            JobId jid;
+            time_t tNext;
+        };
+        typedef Bu::List<JobInfo> JobInfoList;
+
+        JobInfoList getJobInfo();
+
+        /**
+         * The baseclass for timer/schedulers for MiniCron jobs.  Classes that
+         * inherit from this are used to determine when jobs will run and at
+         * what interval.
+         */
+        class Timer
+        {
+        public:
+            Timer();
+            virtual ~Timer();
+
+            /**
+             * Called by MiniCron when each job is run to determine the next
+             * time that a job should be run.  When a job is run, this function
+             * is actually called before the job is executed again so that the
+             * job can tell when the next time it will be run will be.
+             */
+            virtual time_t nextTime()=0;
+
+            /**
+             * This function should return a copy of the child class.
+             */
+            virtual Timer *clone() const = 0;
+        };
+
+        /**
+         * Execute the job every tInterval seconds, also you can delay the
+         * first run by a different amount of time from the job's creation.
+         */
+        class TimerInterval : public Timer
+        {
+        public:
+            TimerInterval( time_t tFirst, time_t tInterval );
+            virtual ~TimerInterval();
+
+            virtual time_t nextTime();
+            virtual Timer *clone() const
+                { return new TimerInterval( *this ); }
+        private:
+            time_t tNext;
+            time_t tInterval;
+        };
+
+        /**
+         * A much more general timer class that can be used for much more
+         * "cron-like" functionality.  The constructor takes a string that
+         * describes the times that the job should be run.  At the moment the
+         * following schemes are understood:
+         *
+         * "daily [hour] [minute]"
+         * "hourly [minute]"
+         * "weekly [day] [hour] [minute]"
+         *
+         * In these examples each word in [brackets] represents a number that
+         * matches the data type in the brackets.  [day] is the number of days
+         * since sunday, 0-6.  You can also use lowercase three character
+         * abbreviations for the day names.
+         *
+         * Many more forms follow.
+         */
+        class TimerBasic : public Timer
+        {
+        public:
+            TimerBasic( const Bu::String &s );
+            virtual ~TimerBasic();
+
+            virtual time_t nextTime();
+            virtual Timer *clone() const
+                { return new TimerBasic( *this ); }
+
+        private:
+            enum Token
+            {
+                tokDaily,
+                tokHourly,
+                tokWeekly,
+                tokMonthly,
+                tokYearly,
+                valInt,
+                tokErr,
+                tokEos
+            };
+            Token lex( Bu::String::const_iterator &i );
+            int lexInt( Bu::String::const_iterator &i );
+            int iVal; //< A temp variable for parsing.
+            time_t tLast;
+            Bu::String sSpec;
+        };
+        
+        /**
+         * Represents a MiniCron Job.  This class is used for both internal
+         * job management as well as job slot interaction and control.  Objects
+         * of this class are passed into the slots that are signaled when a job
+         * is executed.
+         */
+        class Job
+        {
+            friend class Bu::MiniCron;
+        private:
+            Job( const Bu::String &sName, JobId jid, bool bRepeat=true );
+            virtual ~Job();
+
+        public:
+
+            /**
+             * Execute this job once, increment the runcount and schedule the
+             * next occurance of it.
+             */
+            void run( bool bReschedule=true );
+
+            /**
+             * Get the time this job will next run.
+             */
+            time_t getNextRun() const;
+
+            /**
+             * Compute the time this job will next run.
+             */
+            void calcNextRun();
+
+            /**
+             * Replace the current job timer with a new one, this will trigger
+             * a re-schedule.
+             */
+            void setTimer( const Timer &t );
+
+            /**
+             * Stop execution of this job, never execute this job again.
+             */
+            void stop();
+
+            /**
+             * Undo a previous stop.  This will cause a job that has been
+             * stopped or even added with addJobOnce to be set for repeated
+             * scheduling.
+             */
+            void resume();
+
+            /**
+             * Get the unique ID of this job.
+             */
+            JobId getId() const;
+
+            /**
+             * Get the timestamp this job was created.
+             */
+            time_t getTimeCreated() const;
+
+            /**
+             * Get the current run count of this job, how many times it has been
+             * executed.  This is incremented before the slot is signaled.
+             */
+            int getRunCount() const;
+
+            /**
+             * Get the next time that this job will be run.  Certain timers may
+             * have the ability to delay job executions, so this is the earliest
+             * time that the job may run.
+             */
+            time_t getNextRunTime() const;
+
+            /**
+             * Gets the name that was set when the job was created.
+             */
+            Bu::String getName() const;
+
+        private:
+            Bu::String sName;
+            CronSignal sigJob;
+            time_t tNextRun;
+            Timer *pTimer;
+            bool bContinue;
+            JobId jid;
+            time_t tAdded;
+            int iRunCount;
+        };
+
+    private:
+        struct JobPtrCmp
+        {
+            bool operator()( const Job *pLeft, const Job *pRight )
+            {
+                return pLeft->tNextRun < pRight->tNextRun;
+            }
+        };
+        typedef Bu::Heap<Job *, JobPtrCmp> JobHeap;
+        JobHeap hJobs;
+        JobId jidNext;
+    };
 };
 
 #endif
diff --git a/src/stable/multiserver.cpp b/src/stable/multiserver.cpp
index 8856117..bb1cacc 100644
--- a/src/stable/multiserver.cpp
+++ b/src/stable/multiserver.cpp
@@ -20,36 +20,36 @@ Bu::MultiServer::~MultiServer()
 }
 
 void Bu::MultiServer::addProtocol( Bu::Protocol *(*proc)(), int iPort,
-        int nPoolSize )
+    int nPoolSize )
 {
-        hProtos[iPort] = proc;
-        addPort( iPort, nPoolSize );
+    hProtos[iPort] = proc;
+    addPort( iPort, nPoolSize );
 }
 
 void Bu::MultiServer::addProtocol( Protocol *(*proc)(), const String &sAddr,
-        int iPort, int nPoolSize )
+    int iPort, int nPoolSize )
 {
-        hProtos[iPort] = proc;
-        addPort( sAddr, iPort, nPoolSize );
+    hProtos[iPort] = proc;
+    addPort( sAddr, iPort, nPoolSize );
 }
 
 void Bu::MultiServer::onNewConnection( Bu::Client *pClient, int nPort )
 {
-        pClient->setProtocol( hProtos.get( nPort )() );
+    pClient->setProtocol( hProtos.get( nPort )() );
 }
 
 void Bu::MultiServer::onClosedConnection( Bu::Client *pClient )
 {
-        delete pClient->getProtocol();
+    delete pClient->getProtocol();
 }
 
 void Bu::MultiServer::shutdown()
 {
-        Bu::Server::shutdown();
+    Bu::Server::shutdown();
 }
 
 void Bu::MultiServer::tick()
 {
-        Bu::Server::tick();
+    Bu::Server::tick();
 }
 
diff --git a/src/stable/multiserver.h b/src/stable/multiserver.h
index b2f633a..8a49bbd 100644
--- a/src/stable/multiserver.h
+++ b/src/stable/multiserver.h
@@ -13,45 +13,45 @@
 
 namespace Bu
 {
-        class Protocol;
-        class Client;
-
-        template<class T>
-        Protocol *genProtocol()
-        {
-                return new T;
-        }
-
-        class MultiServer : protected Server
-        {
-        public:
-                MultiServer();
-                virtual ~MultiServer();
-
-                void addProtocol( Protocol *(*proc)(), int iPort, int nPoolSize=40 );
-                void addProtocol( Protocol *(*proc)(), const String &sAddr, int iPort,
-                                int nPoolSize=40 );
-                
-                void scan()
-                {
-                        Server::scan();
-                }
-
-                void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 )
-                {
-                        Server::setTimeout( nTimeoutSec, nTimeoutUSec );
-                }
-
-                virtual void onNewConnection( Client *pClient, int nPort );
-                virtual void onClosedConnection( Client *pClient );
-
-                void shutdown();
-
-                void tick();
-
-        private:
-                Bu::Hash<int, Protocol *(*)()> hProtos;
-        };
+    class Protocol;
+    class Client;
+
+    template<class T>
+    Protocol *genProtocol()
+    {
+        return new T;
+    }
+
+    class MultiServer : protected Server
+    {
+    public:
+        MultiServer();
+        virtual ~MultiServer();
+
+        void addProtocol( Protocol *(*proc)(), int iPort, int nPoolSize=40 );
+        void addProtocol( Protocol *(*proc)(), const String &sAddr, int iPort,
+                int nPoolSize=40 );
+        
+        void scan()
+        {
+            Server::scan();
+        }
+
+        void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 )
+        {
+            Server::setTimeout( nTimeoutSec, nTimeoutUSec );
+        }
+
+        virtual void onNewConnection( Client *pClient, int nPort );
+        virtual void onClosedConnection( Client *pClient );
+
+        void shutdown();
+
+        void tick();
+
+    private:
+        Bu::Hash<int, Protocol *(*)()> hProtos;
+    };
 }
 
 #endif
diff --git a/src/stable/mutex.cpp b/src/stable/mutex.cpp
index 947364c..0391d7a 100644
--- a/src/stable/mutex.cpp
+++ b/src/stable/mutex.cpp
@@ -9,26 +9,26 @@
 
 Bu::Mutex::Mutex()
 {
-        pthread_mutex_init( &mutex, NULL );
+    pthread_mutex_init( &mutex, NULL );
 }
 
 Bu::Mutex::~Mutex()
 {
-        pthread_mutex_destroy( &mutex );
+    pthread_mutex_destroy( &mutex );
 }
 
 int Bu::Mutex::lock()
 {
-        return pthread_mutex_lock( &mutex );
+    return pthread_mutex_lock( &mutex );
 }
 
 int Bu::Mutex::unlock()
 {
-        return pthread_mutex_unlock( &mutex );
+    return pthread_mutex_unlock( &mutex );
 }
 
 int Bu::Mutex::trylock()
 {
-        return pthread_mutex_trylock( &mutex );
+    return pthread_mutex_trylock( &mutex );
 }
 
diff --git a/src/stable/mutex.h b/src/stable/mutex.h
index 1898118..23963e3 100644
--- a/src/stable/mutex.h
+++ b/src/stable/mutex.h
@@ -12,57 +12,57 @@
 
 namespace Bu
 {
-        /**
-         * Simple mutex wrapper.  Currently this doesn't do anything extra for you
-         * except keep all of the functionality together in an OO sorta' way and
-         * keep you from having to worry about cleaning up your mutexes properly,
-         * or initing them.
-         *@ingroup Threading
-         */
-        class Mutex
-        {
-        public:
-                /**
-                 * Create an unlocked mutex.
-                 */
-                Mutex();
-                
-                /**
-                 * Destroy a mutex.  This can only be done when a mutex is unlocked.
-                 * Failure to unlock before destroying a mutex object could cause it to
-                 * wait for the mutex to unlock, the odds of which are usually farily
-                 * low at deconstruction time.
-                 */
-                ~Mutex();
+    /**
+     * Simple mutex wrapper.  Currently this doesn't do anything extra for you
+     * except keep all of the functionality together in an OO sorta' way and
+     * keep you from having to worry about cleaning up your mutexes properly,
+     * or initing them.
+     *@ingroup Threading
+     */
+    class Mutex
+    {
+    public:
+        /**
+         * Create an unlocked mutex.
+         */
+        Mutex();
+        
+        /**
+         * Destroy a mutex.  This can only be done when a mutex is unlocked.
+         * Failure to unlock before destroying a mutex object could cause it to
+         * wait for the mutex to unlock, the odds of which are usually farily
+         * low at deconstruction time.
+         */
+        ~Mutex();
 
-                /**
-                 * Lock the mutex.  This causes all future calls to lock on this
-                 * instance of mutex to block until the first thread that called mutex
-                 * unlocks it.  At that point the next thread that called lock will get
-                 * a chance to go to work.  Because of the nature of a mutex lock it is
-                 * a very bad idea to do any kind of serious or rather time consuming
-                 * computation within a locked section.  This can cause thread-deadlock
-                 * and your program may hang.
-                 */
-                int lock();
+        /**
+         * Lock the mutex.  This causes all future calls to lock on this
+         * instance of mutex to block until the first thread that called mutex
+         * unlocks it.  At that point the next thread that called lock will get
+         * a chance to go to work.  Because of the nature of a mutex lock it is
+         * a very bad idea to do any kind of serious or rather time consuming
+         * computation within a locked section.  This can cause thread-deadlock
+         * and your program may hang.
+         */
+        int lock();
 
-                /**
-                 * Unlock the mutex.  This allows the next thread that asked for a lock
-                 * to lock the mutex and continue with execution.
-                 */
-                int unlock();
+        /**
+         * Unlock the mutex.  This allows the next thread that asked for a lock
+         * to lock the mutex and continue with execution.
+         */
+        int unlock();
 
-                /**
-                 * Try to lock the mutex.  This is the option to go with if you cannot
-                 * avoid putting lengthy operations within a locked section.  trylock
-                 * will attempt to lock the mutex, if the mutex is already locked this
-                 * function returns immediately with an error code.
-                 */
-                int trylock();
+        /**
+         * Try to lock the mutex.  This is the option to go with if you cannot
+         * avoid putting lengthy operations within a locked section.  trylock
+         * will attempt to lock the mutex, if the mutex is already locked this
+         * function returns immediately with an error code.
+         */
+        int trylock();
 
-        protected:
-                pthread_mutex_t mutex;  /**< The internal mutex reference. */
-        };
+    protected:
+        pthread_mutex_t mutex;  /**< The internal mutex reference. */
+    };
 }
 
 #endif
diff --git a/src/stable/mutexlocker.cpp b/src/stable/mutexlocker.cpp
index 90b730e..c8465a3 100644
--- a/src/stable/mutexlocker.cpp
+++ b/src/stable/mutexlocker.cpp
@@ -2,23 +2,23 @@
 #include "bu/mutex.h"
 
 Bu::MutexLocker::MutexLocker( Bu::Mutex &mu ) :
-        mu( mu )
+    mu( mu )
 {
-        mu.lock();
+    mu.lock();
 }
 
 Bu::MutexLocker::~MutexLocker()
 {
-        mu.unlock();
+    mu.unlock();
 }
 
 void Bu::MutexLocker::unlock()
 {
-        mu.unlock();
+    mu.unlock();
 }
 
 void Bu::MutexLocker::relock()
 {
-        mu.lock();
+    mu.lock();
 }
 
diff --git a/src/stable/mutexlocker.h b/src/stable/mutexlocker.h
index 7c3c97e..30e71e6 100644
--- a/src/stable/mutexlocker.h
+++ b/src/stable/mutexlocker.h
@@ -3,19 +3,19 @@
 
 namespace Bu
 {
-        class Mutex;
-        class MutexLocker
-        {
-        public:
-                MutexLocker( Mutex &mu );
-                virtual ~MutexLocker();
+    class Mutex;
+    class MutexLocker
+    {
+    public:
+        MutexLocker( Mutex &mu );
+        virtual ~MutexLocker();
 
-                void unlock();
-                void relock();
+        void unlock();
+        void relock();
 
-        private:
-                Mutex &mu;
-        };
+    private:
+        Mutex &mu;
+    };
 };
 
 #endif
diff --git a/src/stable/myriad.cpp b/src/stable/myriad.cpp
index 4be82f0..2a6a725 100644
--- a/src/stable/myriad.cpp
+++ b/src/stable/myriad.cpp
@@ -16,720 +16,720 @@
 using Bu::sio;
 using Bu::Fmt;
 
-#define Myriad_MAGIC_CODE               ((unsigned char *)"\x0a\xd3\xfa\x84")
+#define Myriad_MAGIC_CODE       ((unsigned char *)"\x0a\xd3\xfa\x84")
 
 namespace Bu
 {
-        subExceptionDef( MyriadException )
-        template<typename t> t blkDiv( t total, t block ) {
-                return (total/block)+((total%block==0)?(0):(1));
-        }
+    subExceptionDef( MyriadException )
+    template<typename t> t blkDiv( t total, t block ) {
+        return (total/block)+((total%block==0)?(0):(1));
+    }
 }
 
 Bu::Myriad::Myriad( Bu::Stream &sStore, int iBlockSize, int iPreallocate ) :
-        sStore( sStore ),
-        iBlockSize( iBlockSize ),
-        iBlocks( 0 ),
-        iUsed( 0 ),
-        bHeaderChanged( false )
-{
-        try
-        {
-                initialize();
-        }
-        catch( Bu::MyriadException &e )
-        {
-                if( e.getErrorCode() == MyriadException::emptyStream )
-                {
-                        initialize( iBlockSize, iPreallocate );
-                }
-                else
-                {
-                        throw;
-                }
-        }
+    sStore( sStore ),
+    iBlockSize( iBlockSize ),
+    iBlocks( 0 ),
+    iUsed( 0 ),
+    bHeaderChanged( false )
+{
+    try
+    {
+        initialize();
+    }
+    catch( Bu::MyriadException &e )
+    {
+        if( e.getErrorCode() == MyriadException::emptyStream )
+        {
+            initialize( iBlockSize, iPreallocate );
+        }
+        else
+        {
+            throw;
+        }
+    }
 }
 
 Bu::Myriad::~Myriad()
 {
-        mActiveBlocks.lock();
-        if( !hActiveBlocks.isEmpty() )
-        {
-                sio << "Bu::Myriad::~Myriad(): Error: There are "
-                        << hActiveBlocks.getSize() << " unsynced blocks!" << sio.nl;
-        }
-        mActiveBlocks.unlock();
-        sync();
+    mActiveBlocks.lock();
+    if( !hActiveBlocks.isEmpty() )
+    {
+        sio << "Bu::Myriad::~Myriad(): Error: There are "
+            << hActiveBlocks.getSize() << " unsynced blocks!" << sio.nl;
+    }
+    mActiveBlocks.unlock();
+    sync();
 
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                delete *i;
-        }
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        delete *i;
+    }
 }
 
 void Bu::Myriad::sync()
 {
-        updateHeader();
+    updateHeader();
 
-        mActiveBlocks.lock();
-        for( BlockHash::iterator i = hActiveBlocks.begin(); i; i++ )
-        {
-                if( (*i)->bChanged )
-                {
-                        syncBlock( *i );
-                }
-        }
-        mActiveBlocks.unlock();
+    mActiveBlocks.lock();
+    for( BlockHash::iterator i = hActiveBlocks.begin(); i; i++ )
+    {
+        if( (*i)->bChanged )
+        {
+            syncBlock( *i );
+        }
+    }
+    mActiveBlocks.unlock();
 }
 
 void Bu::Myriad::initialize()
 {
-        MutexLocker mLock( mHeader );
-        lFreeBlocks.clear();
-        sStore.setPosEnd( 0 );
-        Bu::size iSize = sStore.tell();
-        sStore.setPos( 0 );
-
-        unsigned char buf[4];
-        if( sStore.read( buf, 4 ) < 4 )
-                throw MyriadException( MyriadException::emptyStream,
-                                "Input stream appears to be empty.");
-        if( memcmp( buf, Myriad_MAGIC_CODE, 4 ) )
-        {
-                throw MyriadException( MyriadException::invalidFormat,
-                        "Stream does not appear to be a valid Myriad format.");
-        }
-        sStore.read( buf, 2 );
-        if( buf[0] != 1 )
-                throw MyriadException( MyriadException::badVersion,
-                        "We can only handle version 1 for now.");
-        if( buf[1] != 32 )
-                throw MyriadException( MyriadException::invalidWordSize,
-                        "We can only handle 32-bit words at the moment.");
-        sStore.read( &iBlockSize, 4 );
-        int iStreams;
-        sStore.read( &iStreams, 4 );
-
-        iBlocks = iSize/iBlockSize;
-        //sio << "Myriad: iSize=" << iSize << ", iBlockSize=" << iBlockSize
-        //      << ", iBlocks=" << iBlocks << ", iStreams=" << iStreams << sio.nl;
-
-        int iHeaderSize = 14 + 8 + 4;
-        int iHeaderBlocks = 0; //blkDiv( iHeaderSize+4, iBlockSize );
-
-        while( iHeaderSize > iHeaderBlocks*iBlockSize )
-        {
-                iHeaderBlocks = blkDiv( iHeaderSize+4, iBlockSize );
-                iHeaderSize = 14 + 8 + 4*iHeaderBlocks;
-        }
-
-        //sio << "Myriad: iHeaderSize=" << iHeaderSize
-        //      << ", iHeaderBlocks=" << iHeaderBlocks << sio.nl;
-
-        Stream *pFakeHdr = new Stream;
-        pFakeHdr->iId = 0;
-        pFakeHdr->iSize = iHeaderSize;
-        for( int j = 0; j < iHeaderBlocks; j++ )
-        {
-                pFakeHdr->aBlocks.append( j );
-        }
-
-//      sio << "Blocks: " << iBlocks << " (size = " << iSize << "/" << iBlockSize
-//              << ")" << sio.nl;
-        Bu::BitString bsBlockUsed( iBlocks, false );
-        bsBlockUsed.clear();
-
-//      bool bCanSkip = false; // Can skip around, post initial header stream i/o
-        MyriadStream *pIn = new MyriadStream( *this, pFakeHdr );
-        pIn->setPos( sStore.tell() );
-        for( int j = 0; j < iStreams; j++ )
-        {
-                aStreams.append( new Stream() );
-                Stream &s = *aStreams[j];
-                pIn->read( &s.iId, 4 );
-                pIn->read( &s.iSize, 4 );
-                int iSBlocks = blkDiv(s.iSize, iBlockSize);
-        //      sio << "Myriad: - Stream::iId=" << s.iId
-        //              << ", Stream::iSize=" << s.iSize
-        //              << ", Stream::aBlocks=" << iSBlocks
-        //              << ", pIn->tell()=" << pIn->tell() << sio.nl;
-                for( int k = 0; k < iSBlocks; k++ )
-                {
-                        int iBId;
-                        pIn->read( &iBId, 4 );
-        //              sio << "Myriad:   - iBId=" << iBId
-        //                      << ", iStartPos=" << iBId*iBlockSize
-        //                      << ", pIn->tell()=" << pIn->tell() << sio.nl;
-                        s.aBlocks.append( iBId );
-                        bsBlockUsed.setBit( iBId );
-                        iUsed++;
-                        if( (j == 0 && k == iHeaderBlocks-1) )
-                        {
-        //                      sio << "Myriad:   - End of prepartition, unlocking skipping."
-        //                              << sio.nl;
-//                              bCanSkip = true;
-                                MyriadStream *pTmp = new MyriadStream( *this, aStreams[0] );
-        //                      sio << "Myriad    - Position = " << pIn->tell() << sio.nl;
-                                pTmp->setPos( pIn->tell() );
-                                delete pIn;
-                                delete pFakeHdr;
-                                pIn = pTmp;
-                        }
-                }
-        }
-        delete pIn;
-
-        for( int j = 0; j < iBlocks; j++ )
-        {
-                if( bsBlockUsed.getBit( j ) == false )
-                {
-//                      sio << "Preinitialized block " << j << " is free." << sio.nl;
-                        lFreeBlocks.append( j );
-                }
-        }
-//      sio << "Myriad: Blocks used: " << bsBlockUsed.toString() << sio.nl;
+    MutexLocker mLock( mHeader );
+    lFreeBlocks.clear();
+    sStore.setPosEnd( 0 );
+    Bu::size iSize = sStore.tell();
+    sStore.setPos( 0 );
+
+    unsigned char buf[4];
+    if( sStore.read( buf, 4 ) < 4 )
+        throw MyriadException( MyriadException::emptyStream,
+                "Input stream appears to be empty.");
+    if( memcmp( buf, Myriad_MAGIC_CODE, 4 ) )
+    {
+        throw MyriadException( MyriadException::invalidFormat,
+            "Stream does not appear to be a valid Myriad format.");
+    }
+    sStore.read( buf, 2 );
+    if( buf[0] != 1 )
+        throw MyriadException( MyriadException::badVersion,
+            "We can only handle version 1 for now.");
+    if( buf[1] != 32 )
+        throw MyriadException( MyriadException::invalidWordSize,
+            "We can only handle 32-bit words at the moment.");
+    sStore.read( &iBlockSize, 4 );
+    int iStreams;
+    sStore.read( &iStreams, 4 );
+
+    iBlocks = iSize/iBlockSize;
+    //sio << "Myriad: iSize=" << iSize << ", iBlockSize=" << iBlockSize
+    //  << ", iBlocks=" << iBlocks << ", iStreams=" << iStreams << sio.nl;
+
+    int iHeaderSize = 14 + 8 + 4;
+    int iHeaderBlocks = 0; //blkDiv( iHeaderSize+4, iBlockSize );
+
+    while( iHeaderSize > iHeaderBlocks*iBlockSize )
+    {
+        iHeaderBlocks = blkDiv( iHeaderSize+4, iBlockSize );
+        iHeaderSize = 14 + 8 + 4*iHeaderBlocks;
+    }
+
+    //sio << "Myriad: iHeaderSize=" << iHeaderSize
+    //  << ", iHeaderBlocks=" << iHeaderBlocks << sio.nl;
+
+    Stream *pFakeHdr = new Stream;
+    pFakeHdr->iId = 0;
+    pFakeHdr->iSize = iHeaderSize;
+    for( int j = 0; j < iHeaderBlocks; j++ )
+    {
+        pFakeHdr->aBlocks.append( j );
+    }
+
+//  sio << "Blocks: " << iBlocks << " (size = " << iSize << "/" << iBlockSize
+//      << ")" << sio.nl;
+    Bu::BitString bsBlockUsed( iBlocks, false );
+    bsBlockUsed.clear();
+
+//  bool bCanSkip = false; // Can skip around, post initial header stream i/o
+    MyriadStream *pIn = new MyriadStream( *this, pFakeHdr );
+    pIn->setPos( sStore.tell() );
+    for( int j = 0; j < iStreams; j++ )
+    {
+        aStreams.append( new Stream() );
+        Stream &s = *aStreams[j];
+        pIn->read( &s.iId, 4 );
+        pIn->read( &s.iSize, 4 );
+        int iSBlocks = blkDiv(s.iSize, iBlockSize);
+    //  sio << "Myriad: - Stream::iId=" << s.iId
+    //      << ", Stream::iSize=" << s.iSize
+    //      << ", Stream::aBlocks=" << iSBlocks
+    //      << ", pIn->tell()=" << pIn->tell() << sio.nl;
+        for( int k = 0; k < iSBlocks; k++ )
+        {
+            int iBId;
+            pIn->read( &iBId, 4 );
+    //      sio << "Myriad:   - iBId=" << iBId
+    //          << ", iStartPos=" << iBId*iBlockSize
+    //          << ", pIn->tell()=" << pIn->tell() << sio.nl;
+            s.aBlocks.append( iBId );
+            bsBlockUsed.setBit( iBId );
+            iUsed++;
+            if( (j == 0 && k == iHeaderBlocks-1) )
+            {
+    //          sio << "Myriad:   - End of prepartition, unlocking skipping."
+    //              << sio.nl;
+//              bCanSkip = true;
+                MyriadStream *pTmp = new MyriadStream( *this, aStreams[0] );
+    //          sio << "Myriad    - Position = " << pIn->tell() << sio.nl;
+                pTmp->setPos( pIn->tell() );
+                delete pIn;
+                delete pFakeHdr;
+                pIn = pTmp;
+            }
+        }
+    }
+    delete pIn;
+
+    for( int j = 0; j < iBlocks; j++ )
+    {
+        if( bsBlockUsed.getBit( j ) == false )
+        {
+//          sio << "Preinitialized block " << j << " is free." << sio.nl;
+            lFreeBlocks.append( j );
+        }
+    }
+//  sio << "Myriad: Blocks used: " << bsBlockUsed.toString() << sio.nl;
 }
 
 void Bu::Myriad::initialize( int iBlockSize, int iPreAllocate )
 {
-        MutexLocker mLock( mHeader );
-        lFreeBlocks.clear();
-
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                delete *i;
-        }
-        aStreams.clear();
-        iUsed = 0;
-
-        int iHeaderSize = 14 + 8 + 4;
-        int iHeaderBlocks = 0; //blkDiv( iHeaderSize+4, iBlockSize );
-        char cBuf = 1;
-        int iBuf = 0;
-        
-        Stream *pStr = new Stream;
-        pStr->iId = 0;
-
-        while( iHeaderSize > iHeaderBlocks*iBlockSize )
-        {
-                iHeaderBlocks = blkDiv( iHeaderSize+4, iBlockSize );
-                iHeaderSize = 14 + 8 + 4*iHeaderBlocks;
-        }
-
-        iPreAllocate += iHeaderBlocks;
-
-        //sio << "Myriad: iHeaderSize=" << iHeaderSize << ", iBlockSize="
-        //      << iBlockSize << ", iHeaderBlocks=" << iHeaderBlocks << sio.nl;
-        
-//      bsBlockUsed.setSize( iPreAllocate, true );
-        iUsed++;
-
-        char *pBlock = new char[iBlockSize];
-        memset( pBlock, 0, iBlockSize );
-        for( int j = 0; j < iPreAllocate; j++ )
-        {
-                sStore.write( pBlock, iBlockSize );
-        }
-        delete[] (char *)pBlock;
-
-        sStore.setPos( 0 );
-
-        // Magic number
-        sStore.write( Myriad_MAGIC_CODE, 4 );
-
-        // Version (0)
-        sStore.write( &cBuf, 1 );
-
-        // Bits per int
-        cBuf = 32;
-        sStore.write( &cBuf, 1 );
-
-        // The size of each block
-        sStore.write( &iBlockSize, 4 );
-
-        iBuf = 1;
-        // The number of streams
-        sStore.write( &iBuf, 4 );
-        
-        // Stream header
-        iBuf = 0;
-        sStore.write( &iBuf, 4 );
-        sStore.write( &iHeaderSize, 4 );
-        for( iBuf = 0; iBuf < iHeaderBlocks; iBuf++ )
-        {
-                sStore.write( &iBuf, 4 );
-        }
-
-        this->iBlockSize = iBlockSize;
-        this->iBlocks = iPreAllocate;
-        
-        pStr->iSize = sStore.tell();
-//      sio << "Myriad: Actual end of header stream = " << pStr->iSize << sio.nl;
-
-        pStr->iSize = iHeaderSize;
-        for( int j = 0; j < iHeaderBlocks; j++ )
-        {
-//              sio << "Started block " << j << " is header." << sio.nl;
-                pStr->aBlocks.append( j );
-//              bsBlockUsed.setBit( j );
-                iUsed++;
-        }
-        for( int j = iHeaderBlocks; j < this->iBlocks; j++ )
-        {
-//              sio << "Started block " << j << " is free." << sio.nl;
-                lFreeBlocks.append( j );
-        }
-
-        aStreams.append( pStr );
-
-        //sio << bsBlockUsed.toString() << " - " << pStr->aBlocks << sio.nl;
-
-        bHeaderChanged = true;
-        //hStreams.insert( 0, BlockArray( 0 ) );
+    MutexLocker mLock( mHeader );
+    lFreeBlocks.clear();
+
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        delete *i;
+    }
+    aStreams.clear();
+    iUsed = 0;
+
+    int iHeaderSize = 14 + 8 + 4;
+    int iHeaderBlocks = 0; //blkDiv( iHeaderSize+4, iBlockSize );
+    char cBuf = 1;
+    int iBuf = 0;
+    
+    Stream *pStr = new Stream;
+    pStr->iId = 0;
+
+    while( iHeaderSize > iHeaderBlocks*iBlockSize )
+    {
+        iHeaderBlocks = blkDiv( iHeaderSize+4, iBlockSize );
+        iHeaderSize = 14 + 8 + 4*iHeaderBlocks;
+    }
+
+    iPreAllocate += iHeaderBlocks;
+
+    //sio << "Myriad: iHeaderSize=" << iHeaderSize << ", iBlockSize="
+    //  << iBlockSize << ", iHeaderBlocks=" << iHeaderBlocks << sio.nl;
+    
+//  bsBlockUsed.setSize( iPreAllocate, true );
+    iUsed++;
+
+    char *pBlock = new char[iBlockSize];
+    memset( pBlock, 0, iBlockSize );
+    for( int j = 0; j < iPreAllocate; j++ )
+    {
+        sStore.write( pBlock, iBlockSize );
+    }
+    delete[] (char *)pBlock;
+
+    sStore.setPos( 0 );
+
+    // Magic number
+    sStore.write( Myriad_MAGIC_CODE, 4 );
+
+    // Version (0)
+    sStore.write( &cBuf, 1 );
+
+    // Bits per int
+    cBuf = 32;
+    sStore.write( &cBuf, 1 );
+
+    // The size of each block
+    sStore.write( &iBlockSize, 4 );
+
+    iBuf = 1;
+    // The number of streams
+    sStore.write( &iBuf, 4 );
+    
+    // Stream header
+    iBuf = 0;
+    sStore.write( &iBuf, 4 );
+    sStore.write( &iHeaderSize, 4 );
+    for( iBuf = 0; iBuf < iHeaderBlocks; iBuf++ )
+    {
+        sStore.write( &iBuf, 4 );
+    }
+
+    this->iBlockSize = iBlockSize;
+    this->iBlocks = iPreAllocate;
+    
+    pStr->iSize = sStore.tell();
+//  sio << "Myriad: Actual end of header stream = " << pStr->iSize << sio.nl;
+
+    pStr->iSize = iHeaderSize;
+    for( int j = 0; j < iHeaderBlocks; j++ )
+    {
+//      sio << "Started block " << j << " is header." << sio.nl;
+        pStr->aBlocks.append( j );
+//      bsBlockUsed.setBit( j );
+        iUsed++;
+    }
+    for( int j = iHeaderBlocks; j < this->iBlocks; j++ )
+    {
+//      sio << "Started block " << j << " is free." << sio.nl;
+        lFreeBlocks.append( j );
+    }
+
+    aStreams.append( pStr );
+
+    //sio << bsBlockUsed.toString() << " - " << pStr->aBlocks << sio.nl;
+
+    bHeaderChanged = true;
+    //hStreams.insert( 0, BlockArray( 0 ) );
 }
 
 void Bu::Myriad::updateHeader()
 {
-        MutexLocker mLock( mHeader );
-
-        if( bHeaderChanged == false )
-                return;
-        if( !sStore.canWrite() )
-                return;
-
-        char cBuf;
-        int iBuf;
-
-        //for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        //{
-        //      sio << "Myriad: Stream " << Fmt(4) << (*i)->iId << ": " << (*i)->aBlocks << sio.nl;
-        //}
-
-        // Compute the new size of the header.
-        int iHeaderSize = 14 + 8*aStreams.getSize();
-//      sio << "Myriad: updateHeader: aStreams.getSize() = " << aStreams.getSize()
-//              << sio.nl;
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                iHeaderSize += 4*(*i)->aBlocks.getSize();
-//              sio << "Myriad: updateHeader: (*i)->aBlocks.getSize() = "
-//                      << (*i)->aBlocks.getSize() << sio.nl;
-        }
-        int iNewBlocks = blkDiv( iHeaderSize, iBlockSize );
-        while( iNewBlocks > aStreams[0]->aBlocks.getSize() )
-        {
-                int iBlock = findEmptyBlock();
-//              sio << "Myriad: updateHeader: Appending block " << iBlock
-//                      << " to header." << sio.nl;
-                aStreams[0]->aBlocks.append( iBlock );
-//              bsBlockUsed.setBit( iBlock );
-                iUsed++;
-                iHeaderSize += 4;
-                iNewBlocks = blkDiv( iHeaderSize, iBlockSize );
-        }
-        aStreams[0]->iSize = iHeaderSize;
-//      sio << "Myriad: updateHeader: iHeaderSize=" << iHeaderSize
-//              << ", iNewBlocks=" << iNewBlocks << ", curBlocks="
-//              << aStreams[0]->aBlocks.getSize() << sio.nl;
-
-        MyriadStream sHdr( *this, aStreams[0] );
-        sHdr.write( Myriad_MAGIC_CODE, 4 );
-
-        // Version (1)
-        cBuf = 1;
-        sHdr.write( &cBuf, 1 );
-
-        // Bits per int
-        cBuf = 32;
-        sHdr.write( &cBuf, 1 );
-
-        // The size of each block
-        sHdr.write( &iBlockSize, 4 );
-
-        iBuf = aStreams.getSize();
-        // The number of streams
-        sHdr.write( &iBuf, 4 );
-        
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                sHdr.write( &(*i)->iId, 4 );
-                sHdr.write( &(*i)->iSize, 4 );
-                int iUsedBlocks = blkDiv( (*i)->iSize, iBlockSize );
-//              for( BlockArray::iterator j = (*i)->aBlocks.begin(); j; j++ )
-                for( int j = 0; j < iUsedBlocks; j++ )
-                {
-                        sHdr.write( &(*i)->aBlocks[j], 4 );
-                }
-        }
-        
-        bHeaderChanged = false;
+    MutexLocker mLock( mHeader );
+
+    if( bHeaderChanged == false )
+        return;
+    if( !sStore.canWrite() )
+        return;
+
+    char cBuf;
+    int iBuf;
+
+    //for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    //{
+    //  sio << "Myriad: Stream " << Fmt(4) << (*i)->iId << ": " << (*i)->aBlocks << sio.nl;
+    //}
+
+    // Compute the new size of the header.
+    int iHeaderSize = 14 + 8*aStreams.getSize();
+//  sio << "Myriad: updateHeader: aStreams.getSize() = " << aStreams.getSize()
+//      << sio.nl;
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        iHeaderSize += 4*(*i)->aBlocks.getSize();
+//      sio << "Myriad: updateHeader: (*i)->aBlocks.getSize() = "
+//          << (*i)->aBlocks.getSize() << sio.nl;
+    }
+    int iNewBlocks = blkDiv( iHeaderSize, iBlockSize );
+    while( iNewBlocks > aStreams[0]->aBlocks.getSize() )
+    {
+        int iBlock = findEmptyBlock();
+//      sio << "Myriad: updateHeader: Appending block " << iBlock
+//          << " to header." << sio.nl;
+        aStreams[0]->aBlocks.append( iBlock );
+//      bsBlockUsed.setBit( iBlock );
+        iUsed++;
+        iHeaderSize += 4;
+        iNewBlocks = blkDiv( iHeaderSize, iBlockSize );
+    }
+    aStreams[0]->iSize = iHeaderSize;
+//  sio << "Myriad: updateHeader: iHeaderSize=" << iHeaderSize
+//      << ", iNewBlocks=" << iNewBlocks << ", curBlocks="
+//      << aStreams[0]->aBlocks.getSize() << sio.nl;
+
+    MyriadStream sHdr( *this, aStreams[0] );
+    sHdr.write( Myriad_MAGIC_CODE, 4 );
+
+    // Version (1)
+    cBuf = 1;
+    sHdr.write( &cBuf, 1 );
+
+    // Bits per int
+    cBuf = 32;
+    sHdr.write( &cBuf, 1 );
+
+    // The size of each block
+    sHdr.write( &iBlockSize, 4 );
+
+    iBuf = aStreams.getSize();
+    // The number of streams
+    sHdr.write( &iBuf, 4 );
+    
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        sHdr.write( &(*i)->iId, 4 );
+        sHdr.write( &(*i)->iSize, 4 );
+        int iUsedBlocks = blkDiv( (*i)->iSize, iBlockSize );
+//      for( BlockArray::iterator j = (*i)->aBlocks.begin(); j; j++ )
+        for( int j = 0; j < iUsedBlocks; j++ )
+        {
+            sHdr.write( &(*i)->aBlocks[j], 4 );
+        }
+    }
+    
+    bHeaderChanged = false;
 }
 
 int Bu::Myriad::createStream( int iPreAllocate )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        Stream *pStr = new Stream();
-        pStr->iId = aStreams.last()->iId+1;
-        //sio << "Myriad: New stream id=" << pStr->iId << ", iPreAllocate="
-        //      << iPreAllocate << sio.nl;
-        pStr->iSize = 0;
-        aStreams.append( pStr );
+    Stream *pStr = new Stream();
+    pStr->iId = aStreams.last()->iId+1;
+    //sio << "Myriad: New stream id=" << pStr->iId << ", iPreAllocate="
+    //  << iPreAllocate << sio.nl;
+    pStr->iSize = 0;
+    aStreams.append( pStr );
 
-        for( int j = 0; j < iPreAllocate; j++ )
-        {
-                int iFreeBlock = findEmptyBlock();
-//              sio << "Myriad: Adding block " << iFreeBlock << sio.nl;
-                pStr->aBlocks.append( iFreeBlock );
-//              bsBlockUsed.setBit( iFreeBlock );
-                iUsed++;
-        }
+    for( int j = 0; j < iPreAllocate; j++ )
+    {
+        int iFreeBlock = findEmptyBlock();
+//      sio << "Myriad: Adding block " << iFreeBlock << sio.nl;
+        pStr->aBlocks.append( iFreeBlock );
+//      bsBlockUsed.setBit( iFreeBlock );
+        iUsed++;
+    }
 
-        bHeaderChanged = true;
+    bHeaderChanged = true;
 
-        return pStr->iId;
+    return pStr->iId;
 }
 
 int Bu::Myriad::createStreamWithId( int iId, int iPreAllocate )
 {
-        MutexLocker mLock( mHeader );
-
-        try
-        {
-                findStream( iId );
-                throw MyriadException( MyriadException::streamExists,
-                        "There is already a stream with the given id.");
-        }
-        catch( MyriadException &e )
-        {
-                Stream *pStr = new Stream();
-                pStr->iId = iId;
-                //sio << "Myriad: New stream id=" << pStr->iId << ", iPreAllocate="
-                //      << iPreAllocate << sio.nl;
-                pStr->iSize = 0;
-                if( aStreams.last()->iId < iId )
-                {
-                        aStreams.append( pStr );
-                }
-                else
-                {
-                        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-                        {
-                                if( (*i)->iId > iId )
-                                {
-                                        aStreams.insert( i, pStr );
-                                        break;
-                                }
-                        }
-                }
-
-                for( int j = 0; j < iPreAllocate; j++ )
-                {
-                        int iFreeBlock = findEmptyBlock();
-        //              sio << "Myriad: Adding block " << iFreeBlock << sio.nl;
-                        pStr->aBlocks.append( iFreeBlock );
-//                      bsBlockUsed.setBit( iFreeBlock );
-                        iUsed++;
-                }
-
-                bHeaderChanged = true;
-
-                return pStr->iId;
-        }
+    MutexLocker mLock( mHeader );
+
+    try
+    {
+        findStream( iId );
+        throw MyriadException( MyriadException::streamExists,
+            "There is already a stream with the given id.");
+    }
+    catch( MyriadException &e )
+    {
+        Stream *pStr = new Stream();
+        pStr->iId = iId;
+        //sio << "Myriad: New stream id=" << pStr->iId << ", iPreAllocate="
+        //  << iPreAllocate << sio.nl;
+        pStr->iSize = 0;
+        if( aStreams.last()->iId < iId )
+        {
+            aStreams.append( pStr );
+        }
+        else
+        {
+            for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+            {
+                if( (*i)->iId > iId )
+                {
+                    aStreams.insert( i, pStr );
+                    break;
+                }
+            }
+        }
+
+        for( int j = 0; j < iPreAllocate; j++ )
+        {
+            int iFreeBlock = findEmptyBlock();
+    //      sio << "Myriad: Adding block " << iFreeBlock << sio.nl;
+            pStr->aBlocks.append( iFreeBlock );
+//          bsBlockUsed.setBit( iFreeBlock );
+            iUsed++;
+        }
+
+        bHeaderChanged = true;
+
+        return pStr->iId;
+    }
 }
 
 int Bu::Myriad::findEmptyBlock()
 {
-        bHeaderChanged = true;
+    bHeaderChanged = true;
 
-        if( lFreeBlocks.isEmpty() )
-        {
-                sStore.setSize( (iBlocks+1)*(Bu::size)iBlockSize );
-                return iBlocks++;
-        }
-        else
-        {
-                return lFreeBlocks.dequeue();
-        }
+    if( lFreeBlocks.isEmpty() )
+    {
+        sStore.setSize( (iBlocks+1)*(Bu::size)iBlockSize );
+        return iBlocks++;
+    }
+    else
+    {
+        return lFreeBlocks.dequeue();
+    }
 }
 
 void Bu::Myriad::deleteStream( int iId )
 {
-        MutexLocker mLock( mHeader );
-
-        if( iId < 0 )
-                throw MyriadException( MyriadException::invalidStreamId,
-                                "Invalid stream id.");
-        if( iId == 0 )
-                throw MyriadException( MyriadException::protectedStream,
-                                "You cannot delete stream zero, it is protected.");
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                if( (*i)->iId == iId )
-                {
-                        Stream *pStream = *i;
-                        for( BlockArray::iterator j = pStream->aBlocks.begin(); j; j++ )
-                        {
-                                lFreeBlocks.append( *j );
-//                              bsBlockUsed.setBit( *j, false );
-                                iUsed--;
-                        }
-                        aStreams.erase( i );
-                        bHeaderChanged = true;
-                        delete pStream;
-                        return;
-                }
-        }
+    MutexLocker mLock( mHeader );
+
+    if( iId < 0 )
+        throw MyriadException( MyriadException::invalidStreamId,
+                "Invalid stream id.");
+    if( iId == 0 )
+        throw MyriadException( MyriadException::protectedStream,
+                "You cannot delete stream zero, it is protected.");
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        if( (*i)->iId == iId )
+        {
+            Stream *pStream = *i;
+            for( BlockArray::iterator j = pStream->aBlocks.begin(); j; j++ )
+            {
+                lFreeBlocks.append( *j );
+//              bsBlockUsed.setBit( *j, false );
+                iUsed--;
+            }
+            aStreams.erase( i );
+            bHeaderChanged = true;
+            delete pStream;
+            return;
+        }
+    }
 }
 
 Bu::Array<int> Bu::Myriad::getStreamIds()
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        Bu::Array<int> aRet( aStreams.getSize() );
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                aRet.append( (*i)->iId );
-        }
+    Bu::Array<int> aRet( aStreams.getSize() );
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        aRet.append( (*i)->iId );
+    }
 
-        return aRet;
+    return aRet;
 }
 
 int Bu::Myriad::getStreamSize( int iId )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        return findStream( iId )->iSize;
+    return findStream( iId )->iSize;
 }
 
 bool Bu::Myriad::hasStream( int iId )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        try
-        {
-                findStream( iId );
-                return true;
-        }catch(...)
-        {
-                return false;
-        }
+    try
+    {
+        findStream( iId );
+        return true;
+    }catch(...)
+    {
+        return false;
+    }
 }
 
 Bu::MyriadStream Bu::Myriad::openStream( int iId )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        //sio << "Myriad:  Request to open stream: " << iId << sio.nl;
-        return MyriadStream( *this, findStream( iId ) );
+    //sio << "Myriad:  Request to open stream: " << iId << sio.nl;
+    return MyriadStream( *this, findStream( iId ) );
 }
 
 int Bu::Myriad::getNumStreams()
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        return aStreams.getSize();
+    return aStreams.getSize();
 }
 
 int Bu::Myriad::getBlockSize()
 {
-        return iBlockSize;
+    return iBlockSize;
 }
 
 int Bu::Myriad::getNumBlocks()
 {
-        return iBlocks;
+    return iBlocks;
 }
 
 int Bu::Myriad::getNumUsedBlocks()
 {
-        return iUsed;
+    return iUsed;
 }
 
 Bu::size Bu::Myriad::getTotalUsedBytes()
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        Bu::size iTotalSize = 0;
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                iTotalSize += (*i)->iSize;
-        }
-        return iTotalSize;
+    Bu::size iTotalSize = 0;
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        iTotalSize += (*i)->iSize;
+    }
+    return iTotalSize;
 }
 
 Bu::size Bu::Myriad::getTotalUnusedBytes()
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        Bu::size iTotalSize = (iBlocks-iUsed)*iBlockSize;
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                iTotalSize += iBlockSize - ((Bu::size)(*i)->iSize%iBlockSize);
-        }
-        return iTotalSize;
+    Bu::size iTotalSize = (iBlocks-iUsed)*iBlockSize;
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        iTotalSize += iBlockSize - ((Bu::size)(*i)->iSize%iBlockSize);
+    }
+    return iTotalSize;
 }
 
 Bu::size Bu::Myriad::getTotalUnusedBytes( int iFakeBlockSize )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        Bu::size iTotalSize = (iBlocks-iUsed)*iFakeBlockSize;
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                iTotalSize += iFakeBlockSize - ((*i)->iSize%iFakeBlockSize);
-        }
-        return iTotalSize;
+    Bu::size iTotalSize = (iBlocks-iUsed)*iFakeBlockSize;
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        iTotalSize += iFakeBlockSize - ((*i)->iSize%iFakeBlockSize);
+    }
+    return iTotalSize;
 }
 
 Bu::Myriad::Stream *Bu::Myriad::findStream( int iId )
 {
-        for( StreamArray::iterator i = aStreams.begin(); i; i++ )
-        {
-                if( (*i)->iId == iId )
-                        return *i;
-        }
+    for( StreamArray::iterator i = aStreams.begin(); i; i++ )
+    {
+        if( (*i)->iId == iId )
+            return *i;
+    }
 
-        throw MyriadException( MyriadException::noSuchStream,
-                "The requested stream doesn't exist and cannot be opened." );
+    throw MyriadException( MyriadException::noSuchStream,
+        "The requested stream doesn't exist and cannot be opened." );
 
-        return NULL;
+    return NULL;
 }
 
 Bu::Myriad::Block *Bu::Myriad::getBlock( int iBlock )
 {
-//      sio << "Myriad:  Reading block " << iBlock << ", bytes "
-//              << iBlockSize*iBlock << "-" << iBlockSize*(iBlock+1) << sio.nl;
-        Block *pBlock = new Block;
-        pBlock->pData = new char[iBlockSize];
-        sStore.setPos( iBlockSize * (Bu::size)iBlock );
-        sStore.read( pBlock->pData, iBlockSize );
-        pBlock->bChanged = false;
-        pBlock->iBlockIndex = iBlock;
+//  sio << "Myriad:  Reading block " << iBlock << ", bytes "
+//      << iBlockSize*iBlock << "-" << iBlockSize*(iBlock+1) << sio.nl;
+    Block *pBlock = new Block;
+    pBlock->pData = new char[iBlockSize];
+    sStore.setPos( iBlockSize * (Bu::size)iBlock );
+    sStore.read( pBlock->pData, iBlockSize );
+    pBlock->bChanged = false;
+    pBlock->iBlockIndex = iBlock;
 
-        mActiveBlocks.lock();
-        hActiveBlocks.insert( iBlock, pBlock );
-        mActiveBlocks.unlock();
+    mActiveBlocks.lock();
+    hActiveBlocks.insert( iBlock, pBlock );
+    mActiveBlocks.unlock();
 
-        return pBlock;
+    return pBlock;
 }
 
 void Bu::Myriad::releaseBlock( Bu::Myriad::Block *pBlock )
 {
-        if( pBlock == NULL )
-                return;
-//      sio << "Myriad:  Releasing block " << pBlock->iBlockIndex << sio.nl;
-        syncBlock( pBlock );
-        mActiveBlocks.lock();
-        hActiveBlocks.erase( pBlock->iBlockIndex );
-        mActiveBlocks.unlock();
+    if( pBlock == NULL )
+        return;
+//  sio << "Myriad:  Releasing block " << pBlock->iBlockIndex << sio.nl;
+    syncBlock( pBlock );
+    mActiveBlocks.lock();
+    hActiveBlocks.erase( pBlock->iBlockIndex );
+    mActiveBlocks.unlock();
 
-        delete[] pBlock->pData;
-        delete pBlock;
+    delete[] pBlock->pData;
+    delete pBlock;
 }
 
 void Bu::Myriad::syncBlock( Block *pBlock )
 {
-        if( pBlock->bChanged )
-        {
-//              sio << "Myriad:    - Block changed, writing back to stream." << sio.nl;
-                sStore.setPos( iBlockSize * (Bu::size)pBlock->iBlockIndex );
-                sStore.write( pBlock->pData, iBlockSize );
-                pBlock->bChanged = false;
-        }
+    if( pBlock->bChanged )
+    {
+//      sio << "Myriad:    - Block changed, writing back to stream." << sio.nl;
+        sStore.setPos( iBlockSize * (Bu::size)pBlock->iBlockIndex );
+        sStore.write( pBlock->pData, iBlockSize );
+        pBlock->bChanged = false;
+    }
 }
 
 int Bu::Myriad::streamAddBlock( Stream *pStream )
 {
-        MutexLocker mLock( mHeader );
+    MutexLocker mLock( mHeader );
 
-        int iBlock = findEmptyBlock();
-        pStream->aBlocks.append( iBlock );
-//      bsBlockUsed.setBit( iBlock );
-//      bHeaderChanged = true;
-        iUsed++;
-        return iBlock;
+    int iBlock = findEmptyBlock();
+    pStream->aBlocks.append( iBlock );
+//  bsBlockUsed.setBit( iBlock );
+//  bHeaderChanged = true;
+    iUsed++;
+    return iBlock;
 }
 
 void Bu::Myriad::setStreamSize( Stream *pStream, long iSize )
 {
-        MutexLocker mLock( mHeader );
-
-        if( pStream->iSize == iSize )
-        {
-                return;
-        }
-        else if( pStream->iSize > iSize )
-        {
-                // Shrink
-                for( int iNewSize = pStream->aBlocks.getSize()*iBlockSize;
-                         iNewSize-iBlockSize > iSize; iNewSize -= iBlockSize )
-                {
-//                      if( bsBlockUsed.getBit( pStream->aBlocks.last() ) )
-                                iUsed--;
-//                      else
-//                              sio << "Unused block used in stream? " << pStream->aBlocks.last() << sio.nl;
-                        lFreeBlocks.enqueue( pStream->aBlocks.last() );
-//                      bsBlockUsed.setBit( pStream->aBlocks.last(), false );
-                        pStream->aBlocks.eraseLast();
-                }
-                pStream->iSize = iSize;
-                bHeaderChanged = true;
-        }
-        else
-        {
-                // Grow
-                for( int iNewSize = pStream->aBlocks.getSize()*iBlockSize;
-                         iNewSize < iSize; iNewSize += iBlockSize )
-                {
-                        //streamAddBlock( pStream );
-                        int iBlock = findEmptyBlock();
-                        pStream->aBlocks.append( iBlock );
-//                      bsBlockUsed.setBit( iBlock );
-//                      bHeaderChanged = true;
-                        iUsed++;
-                }
-                pStream->iSize = iSize;
-                bHeaderChanged = true;
-        }
+    MutexLocker mLock( mHeader );
+
+    if( pStream->iSize == iSize )
+    {
+        return;
+    }
+    else if( pStream->iSize > iSize )
+    {
+        // Shrink
+        for( int iNewSize = pStream->aBlocks.getSize()*iBlockSize;
+             iNewSize-iBlockSize > iSize; iNewSize -= iBlockSize )
+        {
+//          if( bsBlockUsed.getBit( pStream->aBlocks.last() ) )
+                iUsed--;
+//          else
+//              sio << "Unused block used in stream? " << pStream->aBlocks.last() << sio.nl;
+            lFreeBlocks.enqueue( pStream->aBlocks.last() );
+//          bsBlockUsed.setBit( pStream->aBlocks.last(), false );
+            pStream->aBlocks.eraseLast();
+        }
+        pStream->iSize = iSize;
+        bHeaderChanged = true;
+    }
+    else
+    {
+        // Grow
+        for( int iNewSize = pStream->aBlocks.getSize()*iBlockSize;
+             iNewSize < iSize; iNewSize += iBlockSize )
+        {
+            //streamAddBlock( pStream );
+            int iBlock = findEmptyBlock();
+            pStream->aBlocks.append( iBlock );
+//          bsBlockUsed.setBit( iBlock );
+//          bHeaderChanged = true;
+            iUsed++;
+        }
+        pStream->iSize = iSize;
+        bHeaderChanged = true;
+    }
 }
 
 void Bu::Myriad::headerChanged()
 {
-        bHeaderChanged = true;
+    bHeaderChanged = true;
 }
 
 bool Bu::Myriad::isMyriad( Bu::Stream &sStore )
 {
-        uint8_t uTmp;
+    uint8_t uTmp;
 
-        return isMyriad( sStore, uTmp );
+    return isMyriad( sStore, uTmp );
 }
 
 bool Bu::Myriad::isMyriad( Bu::Stream &sStore, uint8_t &uTmp )
 {
-        sStore.setPos( 0 );
+    sStore.setPos( 0 );
 
-        unsigned char buf[4];
-        if( sStore.read( buf, 4 ) < 4 )
-                throw MyriadException( MyriadException::emptyStream,
-                                "Input stream appears to be empty.");
-        sStore.read( &uTmp, 1 );
-        sStore.setPos( 0 );
-        if( memcmp( buf, Myriad_MAGIC_CODE, 4 ) )
-        {
-                return false;
-        }
-        return true;
+    unsigned char buf[4];
+    if( sStore.read( buf, 4 ) < 4 )
+        throw MyriadException( MyriadException::emptyStream,
+                "Input stream appears to be empty.");
+    sStore.read( &uTmp, 1 );
+    sStore.setPos( 0 );
+    if( memcmp( buf, Myriad_MAGIC_CODE, 4 ) )
+    {
+        return false;
+    }
+    return true;
 }
 
 const Bu::BitString Bu::Myriad::getBlocksUsed() const
 {
-        Bu::BitString bs( iBlocks, false );
-        for( int j = 0; j < iBlocks; j++ )
-                bs.setBit( j );
-        for( IndexList::const_iterator i = lFreeBlocks.begin(); i; i++ )
-                bs.setBit( *i, false );
-        return bs;
+    Bu::BitString bs( iBlocks, false );
+    for( int j = 0; j < iBlocks; j++ )
+        bs.setBit( j );
+    for( IndexList::const_iterator i = lFreeBlocks.begin(); i; i++ )
+        bs.setBit( *i, false );
+    return bs;
 }
 
diff --git a/src/stable/myriad.h b/src/stable/myriad.h
index 6b1db41..4bfd88e 100644
--- a/src/stable/myriad.h
+++ b/src/stable/myriad.h
@@ -18,219 +18,219 @@
 
 namespace Bu
 {
-        class Stream;
-        class MyriadStream;
-
-        subExceptionDeclBegin( MyriadException )
-                enum
-                {
-                        emptyStream,
-                        invalidFormat,
-                        badVersion,
-                        invalidWordSize,
-                        noSuchStream,
-                        streamExists,
-                        invalidStreamId,
-                        protectedStream
-                };
-        subExceptionDeclEnd();
-
-        /**
-         * Myriad block-allocated stream multiplexing system.  This is a system for
-         * creating streams that contain other streams in a flexible and lightweight
-         * manner.  Basically, you can create a file (or any other stream) that can
-         * store any number of flexible, growing streams.  The streams within the
-         * Myriad stream are automatically numbered, not named.  This works more
-         * or less like a filesystem, but without the extra layer for managing
-         * file and directory links.  This would actually be very easy to add
-         * on top of Myriad, but is not required.
-         *
-         * Header format is as follows:
-         *
-         * MMMMvBssssSSSS*
-         * M = Magic number (0AD3FA84)
-         * v = version number
-         * B = Bits per int
-         * s = Blocksize in bytes
-         * S = Number of Streams
-         * 
-         * The * represents the Stream headers, one per stream, as follows:
-         * IIIIssss$
-         * I = Id number of the stream
-         * s = size of stream in bytes
-         *
-         * The $ represents the Block headers, one per used block, as  follows:
-         * IIII
-         * I = Index of the block
-         *
-         * The stream/block data is interleaved in the header, so all blocks stored
-         * with one stream are together.  The block headers are in order, and the
-         * data in them is required to be "solid" you cannot fill partial blocks
-         * mid-way through a stream.
-         *
-         * The initial block starts with the nids header, and is both the zero block
-         * and the zero stream.  For now, the minimum block size is the size needed
-         * to store the base header, the zero stream header, and the first two
-         * blocks of the zero stream, so 30 bytes.  Since it's reccomended to use
-         * a size that will fit evenly into filesystem blocks, then a size of 32 is
-         * probably the smallest reccomended size because all powers of two equal
-         * to or greater than 32 are evenly divisible by 32.
-         *
-         * I have had a thought that if the block size were smaller than 42 bytes
-         * the header would consume the first N blocks where N * block size is
-         * enough space to house the initial header, the first stream header, and
-         * the first N block headers.  This, of course, causes you to hit an
-         * infinite header if the block size is small enough.
-         */
-        class Myriad
-        {
-                friend class MyriadStream;
-        public:
-                /**
-                 * Create a Myriad object that uses the given stream to store data.
-                 * This stream must be random access.  The block size and preallocate
-                 * values passed in are values that will be used if the given stream
-                 * is empty.  In that case the stream will be "formatted" for myriad
-                 * with the specified block size.  If there is already a viable Myriad
-                 * format present in the stream, then the blocksize and preallocate
-                 * values will be ignored and the values from the stream will be used
-                 * instead.  If the stream doesn't appear to be Myriad formatted an
-                 * exception will be thrown.
-                 */
-                Myriad( Bu::Stream &sStore, int iBlockSize=512, int iPreallocate=8 );
-                virtual ~Myriad();
-
-                /**
-                 * Destroy whatever data may be in the base stream and create a new
-                 * Myriad system there with the given blocksize.  Use this with care,
-                 * it will destroy anything that was already in the stream, and
-                 * generally, should not ever have to be used.
-                 */
-                void initialize( int iBlockSize, int iPreAllocate=1 );
-
-                /**
-                 * Create a new stream within the Myriad system.  The ID of the new
-                 * stream is returned.
-                 */
-                int createStream( int iPreAllocate=1 );
-
-                /**
-                 * Create a new stream within the Myriad system with a given id.  The
-                 * id that you provide will be the new id of the stream unless it's
-                 * already used, in which case an error is thrown.  This is primarilly
-                 * useful when copying an old Myriad file into a new one.
-                 */
-                int createStreamWithId( int iId, int iPreAllocate=1 );
-
-                /**
-                 * Delete a stream that's already within the Myriad.
-                 */
-                void deleteStream( int iId );
-
-                /**
-                 * Return a new Stream object assosiated with the given stream ID.
-                 */
-                MyriadStream openStream( int iId );
-
-                Bu::Array<int> getStreamIds();
-                int getStreamSize( int iId );
-                bool hasStream( int iId );
-
-                int getNumStreams();
-                int getBlockSize();
-                int getNumBlocks();
-                int getNumUsedBlocks();
-                Bu::size getTotalUsedBytes();
-                Bu::size getTotalUnusedBytes();
-                Bu::size getTotalUnusedBytes( int iFakeBlockSize );
-
-                /**
-                 * Syncronize the header data, etc. with the storage stream.  It's not
-                 * a bad idea to call this periodically.
-                 */
-                void sync();
-
-                /**
-                 * Read the first few bytes from the given stream and return true/false
-                 * depending on weather or not it's a Myriad stream.  This will throw
-                 * an exception if the stream is empty, or is not random access.
-                 */
-                static bool isMyriad( Bu::Stream &sStore, uint8_t &uVer );
-                
-                /**
-                 * Read the first few bytes from the given stream and return true/false
-                 * depending on weather or not it's a Myriad stream.  This will throw
-                 * an exception if the stream is empty, or is not random access.
-                 */
-                static bool isMyriad( Bu::Stream &sStore );
-
-                const Bu::BitString getBlocksUsed() const;
-
-        private:
-                /**
-                 * Initialize this object based on the data already in the assosiated
-                 * stream.  This will be called automatically for you if you forget,
-                 * but if you want to pre-initialize for some reason, just call this
-                 * once before you actually start doing anything with your Myriad.
-                 */
-                void initialize();
-
-                enum
-                {
-                        blockUnused     =       0xFFFFFFFFUL
-                };
-                
-                typedef Bu::Array<int> BlockArray;
-                class Stream
-                {
-                public:
-                        int iId;
-                        int iSize;
-                        BlockArray aBlocks;
-                };
-                typedef Bu::Array<Stream *> StreamArray;
-
-                class Block
-                {
-                public:
-                        char *pData;
-                        bool bChanged;
-                        int iBlockIndex;
-                };
-
-                void updateHeader();
-                int findEmptyBlock();
-
-                /**
-                 *@todo Change this to use a binary search, it's nicer.
-                 */
-                Stream *findStream( int iId );
-
-                Block *getBlock( int iBlock );
-                void releaseBlock( Block *pBlock );
-                void syncBlock( Block *pBlock );
-
-                int streamAddBlock( Stream *pStream );
-                void setStreamSize( Stream *pStream, long iSize );
-
-                void headerChanged();
-
-        private:
-                Bu::Stream &sStore;
-                int iBlockSize;
-                int iBlocks;
-                int iUsed;
-                typedef Bu::List<int> IndexList;
-                IndexList lFreeBlocks;
-//              Bu::BitString bsBlockUsed;
-                StreamArray aStreams;
-                typedef Bu::Hash<int, Block *> BlockHash;
-                BlockHash hActiveBlocks;
-                bool bHeaderChanged;
-
-                Bu::Mutex mHeader;
-                Bu::Mutex mActiveBlocks;
-        };
+    class Stream;
+    class MyriadStream;
+
+    subExceptionDeclBegin( MyriadException )
+        enum
+        {
+            emptyStream,
+            invalidFormat,
+            badVersion,
+            invalidWordSize,
+            noSuchStream,
+            streamExists,
+            invalidStreamId,
+            protectedStream
+        };
+    subExceptionDeclEnd();
+
+    /**
+     * Myriad block-allocated stream multiplexing system.  This is a system for
+     * creating streams that contain other streams in a flexible and lightweight
+     * manner.  Basically, you can create a file (or any other stream) that can
+     * store any number of flexible, growing streams.  The streams within the
+     * Myriad stream are automatically numbered, not named.  This works more
+     * or less like a filesystem, but without the extra layer for managing
+     * file and directory links.  This would actually be very easy to add
+     * on top of Myriad, but is not required.
+     *
+     * Header format is as follows:
+     *
+     * MMMMvBssssSSSS*
+     * M = Magic number (0AD3FA84)
+     * v = version number
+     * B = Bits per int
+     * s = Blocksize in bytes
+     * S = Number of Streams
+     * 
+     * The * represents the Stream headers, one per stream, as follows:
+     * IIIIssss$
+     * I = Id number of the stream
+     * s = size of stream in bytes
+     *
+     * The $ represents the Block headers, one per used block, as  follows:
+     * IIII
+     * I = Index of the block
+     *
+     * The stream/block data is interleaved in the header, so all blocks stored
+     * with one stream are together.  The block headers are in order, and the
+     * data in them is required to be "solid" you cannot fill partial blocks
+     * mid-way through a stream.
+     *
+     * The initial block starts with the nids header, and is both the zero block
+     * and the zero stream.  For now, the minimum block size is the size needed
+     * to store the base header, the zero stream header, and the first two
+     * blocks of the zero stream, so 30 bytes.  Since it's reccomended to use
+     * a size that will fit evenly into filesystem blocks, then a size of 32 is
+     * probably the smallest reccomended size because all powers of two equal
+     * to or greater than 32 are evenly divisible by 32.
+     *
+     * I have had a thought that if the block size were smaller than 42 bytes
+     * the header would consume the first N blocks where N * block size is
+     * enough space to house the initial header, the first stream header, and
+     * the first N block headers.  This, of course, causes you to hit an
+     * infinite header if the block size is small enough.
+     */
+    class Myriad
+    {
+        friend class MyriadStream;
+    public:
+        /**
+         * Create a Myriad object that uses the given stream to store data.
+         * This stream must be random access.  The block size and preallocate
+         * values passed in are values that will be used if the given stream
+         * is empty.  In that case the stream will be "formatted" for myriad
+         * with the specified block size.  If there is already a viable Myriad
+         * format present in the stream, then the blocksize and preallocate
+         * values will be ignored and the values from the stream will be used
+         * instead.  If the stream doesn't appear to be Myriad formatted an
+         * exception will be thrown.
+         */
+        Myriad( Bu::Stream &sStore, int iBlockSize=512, int iPreallocate=8 );
+        virtual ~Myriad();
+
+        /**
+         * Destroy whatever data may be in the base stream and create a new
+         * Myriad system there with the given blocksize.  Use this with care,
+         * it will destroy anything that was already in the stream, and
+         * generally, should not ever have to be used.
+         */
+        void initialize( int iBlockSize, int iPreAllocate=1 );
+
+        /**
+         * Create a new stream within the Myriad system.  The ID of the new
+         * stream is returned.
+         */
+        int createStream( int iPreAllocate=1 );
+
+        /**
+         * Create a new stream within the Myriad system with a given id.  The
+         * id that you provide will be the new id of the stream unless it's
+         * already used, in which case an error is thrown.  This is primarilly
+         * useful when copying an old Myriad file into a new one.
+         */
+        int createStreamWithId( int iId, int iPreAllocate=1 );
+
+        /**
+         * Delete a stream that's already within the Myriad.
+         */
+        void deleteStream( int iId );
+
+        /**
+         * Return a new Stream object assosiated with the given stream ID.
+         */
+        MyriadStream openStream( int iId );
+
+        Bu::Array<int> getStreamIds();
+        int getStreamSize( int iId );
+        bool hasStream( int iId );
+
+        int getNumStreams();
+        int getBlockSize();
+        int getNumBlocks();
+        int getNumUsedBlocks();
+        Bu::size getTotalUsedBytes();
+        Bu::size getTotalUnusedBytes();
+        Bu::size getTotalUnusedBytes( int iFakeBlockSize );
+
+        /**
+         * Syncronize the header data, etc. with the storage stream.  It's not
+         * a bad idea to call this periodically.
+         */
+        void sync();
+
+        /**
+         * Read the first few bytes from the given stream and return true/false
+         * depending on weather or not it's a Myriad stream.  This will throw
+         * an exception if the stream is empty, or is not random access.
+         */
+        static bool isMyriad( Bu::Stream &sStore, uint8_t &uVer );
+        
+        /**
+         * Read the first few bytes from the given stream and return true/false
+         * depending on weather or not it's a Myriad stream.  This will throw
+         * an exception if the stream is empty, or is not random access.
+         */
+        static bool isMyriad( Bu::Stream &sStore );
+
+        const Bu::BitString getBlocksUsed() const;
+
+    private:
+        /**
+         * Initialize this object based on the data already in the assosiated
+         * stream.  This will be called automatically for you if you forget,
+         * but if you want to pre-initialize for some reason, just call this
+         * once before you actually start doing anything with your Myriad.
+         */
+        void initialize();
+
+        enum
+        {
+            blockUnused =   0xFFFFFFFFUL
+        };
+        
+        typedef Bu::Array<int> BlockArray;
+        class Stream
+        {
+        public:
+            int iId;
+            int iSize;
+            BlockArray aBlocks;
+        };
+        typedef Bu::Array<Stream *> StreamArray;
+
+        class Block
+        {
+        public:
+            char *pData;
+            bool bChanged;
+            int iBlockIndex;
+        };
+
+        void updateHeader();
+        int findEmptyBlock();
+
+        /**
+         *@todo Change this to use a binary search, it's nicer.
+         */
+        Stream *findStream( int iId );
+
+        Block *getBlock( int iBlock );
+        void releaseBlock( Block *pBlock );
+        void syncBlock( Block *pBlock );
+
+        int streamAddBlock( Stream *pStream );
+        void setStreamSize( Stream *pStream, long iSize );
+
+        void headerChanged();
+
+    private:
+        Bu::Stream &sStore;
+        int iBlockSize;
+        int iBlocks;
+        int iUsed;
+        typedef Bu::List<int> IndexList;
+        IndexList lFreeBlocks;
+//      Bu::BitString bsBlockUsed;
+        StreamArray aStreams;
+        typedef Bu::Hash<int, Block *> BlockHash;
+        BlockHash hActiveBlocks;
+        bool bHeaderChanged;
+
+        Bu::Mutex mHeader;
+        Bu::Mutex mActiveBlocks;
+    };
 };
 
 #endif
diff --git a/src/stable/myriadstream.cpp b/src/stable/myriadstream.cpp
index 58d3936..c33445a 100644
--- a/src/stable/myriadstream.cpp
+++ b/src/stable/myriadstream.cpp
@@ -9,7 +9,7 @@
 
 #include <string.h>
 
-// #define MYRIAD_STREAM_DEBUG  1
+// #define MYRIAD_STREAM_DEBUG  1
 
 #ifdef MYRIAD_STREAM_DEBUG
 #include "bu/sio.h"
@@ -19,27 +19,27 @@ using Bu::Fmt;
 #endif
 
 Bu::MyriadStream::MyriadStream( Bu::Myriad &rMyriad,
-                Bu::Myriad::Stream *pStream ) :
-        rMyriad( rMyriad ),
-        pStream( pStream ),
-        pCurBlock( NULL ),
-        iPos( 0 )
+        Bu::Myriad::Stream *pStream ) :
+    rMyriad( rMyriad ),
+    pStream( pStream ),
+    pCurBlock( NULL ),
+    iPos( 0 )
 {
 #ifdef MYRIAD_STREAM_DEBUG
-        sio << "MyriadStream: " << __LINE__ << ": Created, iId=" << pStream->iId << ", iSize="
-                << pStream->iSize << sio.nl;
+    sio << "MyriadStream: " << __LINE__ << ": Created, iId=" << pStream->iId << ", iSize="
+        << pStream->iSize << sio.nl;
 #endif
-        //pCurBlock = rMyriad.newBlock();
-        //rMyriad.getBlock( uStream, pCurBlock );
-        //uSize = pCurBlock->uBytesUsed;
+    //pCurBlock = rMyriad.newBlock();
+    //rMyriad.getBlock( uStream, pCurBlock );
+    //uSize = pCurBlock->uBytesUsed;
 }
 
 Bu::MyriadStream::~MyriadStream()
 {
-        if( pCurBlock )
-                rMyriad.releaseBlock( pCurBlock );
-        //rMyriad.updateStreamSize( uStream, uSize );
-        //rMyriad.deleteBlock( pCurBlock );
+    if( pCurBlock )
+        rMyriad.releaseBlock( pCurBlock );
+    //rMyriad.updateStreamSize( uStream, uSize );
+    //rMyriad.deleteBlock( pCurBlock );
 }
 
 void Bu::MyriadStream::close()
@@ -49,200 +49,200 @@ void Bu::MyriadStream::close()
 Bu::size Bu::MyriadStream::read( void *pBuf, Bu::size nBytes )
 {
 #ifdef MYRIAD_STREAM_DEBUG
-        sio << "MyriadStream: read: " << __LINE__ << ": Started, asked to read " << nBytes << "b."
-                << sio.nl;
+    sio << "MyriadStream: read: " << __LINE__ << ": Started, asked to read " << nBytes << "b."
+        << sio.nl;
 #endif
-        if( nBytes > (Bu::size)pStream->iSize-iPos )
-                nBytes = pStream->iSize-iPos;
-        if( nBytes <= 0 )
-                return 0;
-        int iLeft = nBytes;
+    if( nBytes > (Bu::size)pStream->iSize-iPos )
+        nBytes = pStream->iSize-iPos;
+    if( nBytes <= 0 )
+        return 0;
+    int iLeft = nBytes;
 #ifdef MYRIAD_STREAM_DEBUG
-        sio << "MyriadStream: read: " << __LINE__ << ": Started, going to read " << nBytes << "b."
-                << sio.nl;
+    sio << "MyriadStream: read: " << __LINE__ << ": Started, going to read " << nBytes << "b."
+        << sio.nl;
 #endif
-        if( pCurBlock == NULL )
-        {
+    if( pCurBlock == NULL )
+    {
 #ifdef MYRIAD_STREAM_DEBUG
-                sio << "MyriadStream: read: " << __LINE__ << ": No block loaded, loading initial block."
-                        << sio.nl;
+        sio << "MyriadStream: read: " << __LINE__ << ": No block loaded, loading initial block."
+            << sio.nl;
 #endif
-                pCurBlock = rMyriad.getBlock(
-                        pStream->aBlocks[iPos/rMyriad.iBlockSize]
-                        );
-        }
-        while( iLeft > 0 )
-        {
-                int iCurBlock = pStream->aBlocks[iPos/rMyriad.iBlockSize];
-                if( pCurBlock->iBlockIndex != iCurBlock )
-                {
+        pCurBlock = rMyriad.getBlock(
+            pStream->aBlocks[iPos/rMyriad.iBlockSize]
+            );
+    }
+    while( iLeft > 0 )
+    {
+        int iCurBlock = pStream->aBlocks[iPos/rMyriad.iBlockSize];
+        if( pCurBlock->iBlockIndex != iCurBlock )
+        {
 #ifdef MYRIAD_STREAM_DEBUG
-                        sio << "MyriadStream: read: " << __LINE__ << ": Loading new block " << iCurBlock << "."
-                                << sio.nl;
+            sio << "MyriadStream: read: " << __LINE__ << ": Loading new block " << iCurBlock << "."
+                << sio.nl;
 #endif
-                        rMyriad.releaseBlock( pCurBlock );
-                        pCurBlock = rMyriad.getBlock( iCurBlock );
-                }
-
-                int iAmnt = Bu::buMin(
-                        Bu::buMin(
-                                rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
-                                iLeft
-                                ),
-                        pStream->iSize-iPos
-                        );
+            rMyriad.releaseBlock( pCurBlock );
+            pCurBlock = rMyriad.getBlock( iCurBlock );
+        }
+
+        int iAmnt = Bu::buMin(
+            Bu::buMin(
+                rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
+                iLeft
+                ),
+            pStream->iSize-iPos
+            );
 #ifdef MYRIAD_STREAM_DEBUG
-                sio << "MyriadStream: read: " << __LINE__ << ": Copying out bytes: "
-                        << iPos << "(" << (iPos%rMyriad.iBlockSize) << ")+"
-                        << iAmnt
-                        << ", " << iLeft << "b left." << sio.nl;
+        sio << "MyriadStream: read: " << __LINE__ << ": Copying out bytes: "
+            << iPos << "(" << (iPos%rMyriad.iBlockSize) << ")+"
+            << iAmnt
+            << ", " << iLeft << "b left." << sio.nl;
 #endif
-                memcpy(
-                        pBuf,
-                        pCurBlock->pData+(iPos%rMyriad.iBlockSize),
-                        iAmnt
-                        );
-                iPos += iAmnt;
-                pBuf = &((char *)pBuf)[iAmnt];
-                iLeft -= iAmnt;
-        }
-        return nBytes;
+        memcpy(
+            pBuf,
+            pCurBlock->pData+(iPos%rMyriad.iBlockSize),
+            iAmnt
+            );
+        iPos += iAmnt;
+        pBuf = &((char *)pBuf)[iAmnt];
+        iLeft -= iAmnt;
+    }
+    return nBytes;
 }
 
 Bu::size Bu::MyriadStream::write( const void *pBuf, Bu::size nBytes )
 {
-        if( nBytes <= 0 )
-                return 0;
+    if( nBytes <= 0 )
+        return 0;
 
 #ifdef MYRIAD_STREAM_DEBUG
-        sio << "MyriadStream: write: " << __LINE__ << ": Started, asked to write " << nBytes << "b."
-                << sio.nl;
+    sio << "MyriadStream: write: " << __LINE__ << ": Started, asked to write " << nBytes << "b."
+        << sio.nl;
 #endif
-        if( nBytes <= 0 )
-                return 0;
-        int iLeft = nBytes;
-        /*
-        if( pCurBlock == NULL )
-        {
+    if( nBytes <= 0 )
+        return 0;
+    int iLeft = nBytes;
+    /*
+    if( pCurBlock == NULL )
+    {
 #ifdef MYRIAD_STREAM_DEBUG
-                sio << "MyriadStream: write: No block loaded, loading initial block."
-                        << sio.nl;
+        sio << "MyriadStream: write: No block loaded, loading initial block."
+            << sio.nl;
 #endif
-                pCurBlock = rMyriad.getBlock(
-                        pStream->aBlocks[iPos/rMyriad.iBlockSize]
-                        );
-        }*/
-        
-        while( iLeft > 0 )
-        {
-                int iCurBlock;
-                if( iPos/rMyriad.iBlockSize < pStream->aBlocks.getSize() )
-                {
-                        iCurBlock = pStream->aBlocks[iPos/rMyriad.iBlockSize];
-                }
-                else
-                {
-                        iCurBlock = rMyriad.streamAddBlock( pStream );
+        pCurBlock = rMyriad.getBlock(
+            pStream->aBlocks[iPos/rMyriad.iBlockSize]
+            );
+    }*/
+    
+    while( iLeft > 0 )
+    {
+        int iCurBlock;
+        if( iPos/rMyriad.iBlockSize < pStream->aBlocks.getSize() )
+        {
+            iCurBlock = pStream->aBlocks[iPos/rMyriad.iBlockSize];
+        }
+        else
+        {
+            iCurBlock = rMyriad.streamAddBlock( pStream );
 #ifdef MYRIAD_STREAM_DEBUG
-                        sio << "MyriadStream: write: " << __LINE__ << ": New block allocated and appended: "
-                                << iCurBlock << "." << sio.nl;
+            sio << "MyriadStream: write: " << __LINE__ << ": New block allocated and appended: "
+                << iCurBlock << "." << sio.nl;
 
 #endif
-                }
-                if( !pCurBlock || pCurBlock->iBlockIndex != iCurBlock )
-                {
+        }
+        if( !pCurBlock || pCurBlock->iBlockIndex != iCurBlock )
+        {
 #ifdef MYRIAD_STREAM_DEBUG
-                        sio << "MyriadStream: write: " << __LINE__ << ": Loading new block " << iCurBlock << "."
-                                << sio.nl;
+            sio << "MyriadStream: write: " << __LINE__ << ": Loading new block " << iCurBlock << "."
+                << sio.nl;
 #endif
-                        rMyriad.releaseBlock( pCurBlock );
-                        pCurBlock = rMyriad.getBlock( iCurBlock );
-                }
-                pCurBlock->bChanged = true;
-                
-                // There are two main writing modes when it comes down to it.
-                // Overwrite mode and append mode.  Append is what pretty much always
-                // happens when creating a new stream.
-                if( iPos < pStream->iSize )
-                {
-                        int iAmnt = Bu::buMin(
-                                Bu::buMin(
-                                        rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
-                                        iLeft
-                                        ),
-                                pStream->iSize-iPos
-                                );
+            rMyriad.releaseBlock( pCurBlock );
+            pCurBlock = rMyriad.getBlock( iCurBlock );
+        }
+        pCurBlock->bChanged = true;
+        
+        // There are two main writing modes when it comes down to it.
+        // Overwrite mode and append mode.  Append is what pretty much always
+        // happens when creating a new stream.
+        if( iPos < pStream->iSize )
+        {
+            int iAmnt = Bu::buMin(
+                Bu::buMin(
+                    rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
+                    iLeft
+                    ),
+                pStream->iSize-iPos
+                );
 #ifdef MYRIAD_STREAM_DEBUG
-                        sio << "MyriadStream: write (ovr): " << __LINE__ << ": Copying in bytes: "
-                                << (iPos%rMyriad.iBlockSize) << "+"
-                                << iAmnt
-                                << ", " << iLeft << "b left." << sio.nl;
+            sio << "MyriadStream: write (ovr): " << __LINE__ << ": Copying in bytes: "
+                << (iPos%rMyriad.iBlockSize) << "+"
+                << iAmnt
+                << ", " << iLeft << "b left." << sio.nl;
 #endif
-                        memcpy(
-                                pCurBlock->pData+(iPos%rMyriad.iBlockSize),
-                                pBuf,
-                                iAmnt
-                                );
-                        iPos += iAmnt;
-                        pBuf = &((char *)pBuf)[iAmnt];
-                        iLeft -= iAmnt;
-                }
-                else
-                {
-                        int iAmnt = Bu::buMin(
-                                rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
-                                iLeft
-                                );
+            memcpy(
+                pCurBlock->pData+(iPos%rMyriad.iBlockSize),
+                pBuf,
+                iAmnt
+                );
+            iPos += iAmnt;
+            pBuf = &((char *)pBuf)[iAmnt];
+            iLeft -= iAmnt;
+        }
+        else
+        {
+            int iAmnt = Bu::buMin(
+                rMyriad.iBlockSize - iPos%rMyriad.iBlockSize,
+                iLeft
+                );
 #ifdef MYRIAD_STREAM_DEBUG
-                        sio << "MyriadStream: write (app): " << __LINE__ << ": Copying in bytes: "
-                                << (iPos%rMyriad.iBlockSize) << "+"
-                                << iAmnt
-                                << ", " << iLeft << "b left." << sio.nl;
+            sio << "MyriadStream: write (app): " << __LINE__ << ": Copying in bytes: "
+                << (iPos%rMyriad.iBlockSize) << "+"
+                << iAmnt
+                << ", " << iLeft << "b left." << sio.nl;
 #endif
-                        memcpy(
-                                pCurBlock->pData+(iPos%rMyriad.iBlockSize),
-                                pBuf,
-                                iAmnt
-                                );
-                        iPos += iAmnt;
-                        pStream->iSize += iAmnt;
-                        rMyriad.headerChanged();
-                        pBuf = &((char *)pBuf)[iAmnt];
-                        iLeft -= iAmnt;
-                }
-        }
-
-        return nBytes;
+            memcpy(
+                pCurBlock->pData+(iPos%rMyriad.iBlockSize),
+                pBuf,
+                iAmnt
+                );
+            iPos += iAmnt;
+            pStream->iSize += iAmnt;
+            rMyriad.headerChanged();
+            pBuf = &((char *)pBuf)[iAmnt];
+            iLeft -= iAmnt;
+        }
+    }
+
+    return nBytes;
 }
 
 Bu::size Bu::MyriadStream::tell()
 {
-        return iPos;
+    return iPos;
 }
 
 void Bu::MyriadStream::seek( Bu::size offset )
 {
-        iPos += offset;
+    iPos += offset;
 }
 
 void Bu::MyriadStream::setPos( Bu::size pos )
 {
-        iPos = pos;
+    iPos = pos;
 }
 
 void Bu::MyriadStream::setPosEnd( Bu::size pos )
 {
-        iPos = pStream->iSize-pos;
+    iPos = pStream->iSize-pos;
 }
 
 bool Bu::MyriadStream::isEos()
 {
-        return iPos >= pStream->iSize;
+    return iPos >= pStream->iSize;
 }
 
 bool Bu::MyriadStream::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::MyriadStream::flush()
@@ -251,32 +251,32 @@ void Bu::MyriadStream::flush()
 
 bool Bu::MyriadStream::canRead()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MyriadStream::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MyriadStream::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MyriadStream::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MyriadStream::isSeekable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::MyriadStream::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::MyriadStream::setBlocking( bool /*bBlocking*/ )
@@ -285,25 +285,25 @@ void Bu::MyriadStream::setBlocking( bool /*bBlocking*/ )
 
 void Bu::MyriadStream::setSize( Bu::size iSize )
 {
-        if( iSize < 0 )
-                iSize = 0;
-        rMyriad.setStreamSize( pStream, iSize );
-        if( iPos > iSize )
-                iPos = iSize;
+    if( iSize < 0 )
+        iSize = 0;
+    rMyriad.setStreamSize( pStream, iSize );
+    if( iPos > iSize )
+        iPos = iSize;
 }
 
 Bu::size Bu::MyriadStream::getSize() const
 {
-        return pStream->iSize;
+    return pStream->iSize;
 }
 
 Bu::size Bu::MyriadStream::getBlockSize() const
 {
-        return rMyriad.getBlockSize();
+    return rMyriad.getBlockSize();
 }
 
 Bu::String Bu::MyriadStream::getLocation() const
 {
-        return Bu::String("%1").arg( pStream->iId );
+    return Bu::String("%1").arg( pStream->iId );
 }
 
diff --git a/src/stable/myriadstream.h b/src/stable/myriadstream.h
index 7cc2fc0..fe7453f 100644
--- a/src/stable/myriadstream.h
+++ b/src/stable/myriadstream.h
@@ -13,49 +13,49 @@
 
 namespace Bu
 {
-        class MyriadStream : public Bu::Stream
-        {
-                friend class Myriad;
-        private:
-                /**
-                 * These can only be created by the Myriad class.
-                 */
-                MyriadStream( Myriad &rMyriad, Myriad::Stream *pStream );
-
-        public:
-                virtual ~MyriadStream();
-
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
-
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-
-        private:
-                Myriad &rMyriad;
-                Myriad::Stream *pStream;
-                Myriad::Block *pCurBlock;
-                int iBlockSize;
-                int iPos; 
-        };
+    class MyriadStream : public Bu::Stream
+    {
+        friend class Myriad;
+    private:
+        /**
+         * These can only be created by the Myriad class.
+         */
+        MyriadStream( Myriad &rMyriad, Myriad::Stream *pStream );
+
+    public:
+        virtual ~MyriadStream();
+
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
+
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+
+    private:
+        Myriad &rMyriad;
+        Myriad::Stream *pStream;
+        Myriad::Block *pCurBlock;
+        int iBlockSize;
+        int iPos; 
+    };
 };
 
 #endif
diff --git a/src/stable/nullstream.cpp b/src/stable/nullstream.cpp
index 0dcede2..5f568b9 100644
--- a/src/stable/nullstream.cpp
+++ b/src/stable/nullstream.cpp
@@ -8,8 +8,8 @@
 #include "bu/nullstream.h"
 
 Bu::NullStream::NullStream() :
-        sRead( 0 ),
-        sWrote( 0 )
+    sRead( 0 ),
+    sWrote( 0 )
 {
 }
 
@@ -19,31 +19,31 @@ Bu::NullStream::~NullStream()
 
 void Bu::NullStream::close()
 {
-        sRead = sWrote = 0;
+    sRead = sWrote = 0;
 }
 
 Bu::size Bu::NullStream::read( void *pBuf, Bu::size nBytes )
 {
-        memset( pBuf, 0, nBytes );
-        sRead += nBytes;
-        return nBytes;
+    memset( pBuf, 0, nBytes );
+    sRead += nBytes;
+    return nBytes;
 }
 
 Bu::String Bu::NullStream::readLine()
 {
-        sRead++;
-        return Bu::String("\0", 1 );
+    sRead++;
+    return Bu::String("\0", 1 );
 }
 
 Bu::size Bu::NullStream::write( const void *, Bu::size nBytes )
 {
-        sWrote += nBytes;
-        return nBytes;
+    sWrote += nBytes;
+    return nBytes;
 }
 
 Bu::size Bu::NullStream::tell()
 {
-        return sRead + sWrote;
+    return sRead + sWrote;
 }
 
 void Bu::NullStream::seek( Bu::size )
@@ -60,12 +60,12 @@ void Bu::NullStream::setPosEnd( Bu::size )
 
 bool Bu::NullStream::isEos()
 {
-        return false;
+    return false;
 }
 
 bool Bu::NullStream::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::NullStream::flush()
@@ -74,32 +74,32 @@ void Bu::NullStream::flush()
 
 bool Bu::NullStream::canRead()
 {
-        return true;
+    return true;
 }
 
 bool Bu::NullStream::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::NullStream::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::NullStream::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::NullStream::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::NullStream::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::NullStream::setBlocking( bool )
@@ -112,16 +112,16 @@ void Bu::NullStream::setSize( Bu::size )
 
 Bu::size Bu::NullStream::getSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::NullStream::getBlockSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::String Bu::NullStream::getLocation() const
 {
-        return "";
+    return "";
 }
 
diff --git a/src/stable/nullstream.h b/src/stable/nullstream.h
index 034b0c5..a8b24e3 100644
--- a/src/stable/nullstream.h
+++ b/src/stable/nullstream.h
@@ -12,56 +12,56 @@
 
 namespace Bu
 {
-        /**
-         * Works a lot like /dev/null on *nix style systems.  This class allows
-         * infinite reading and writing.  All operatorns "succeed" even if they
-         * don't seem to do anything.  This is great for testing writing code or
-         * doing dry runs.  When reading, it will produce NULL bytes, so any
-         * application that would like the ability to produce null streams as a
-         * snap-in replacement for any other Bu::Stream, this is the right option.
-         *
-         * As an added feature, the NullStream will track how many bytes it was
-         * asked to read and write, allowing you to use it to determine how many
-         * bytes a write opretion would use without actually writing anything.
-         */
-        class NullStream : public Bu::Stream
-        {
-        public:
-                NullStream();
-                virtual ~NullStream();
+    /**
+     * Works a lot like /dev/null on *nix style systems.  This class allows
+     * infinite reading and writing.  All operatorns "succeed" even if they
+     * don't seem to do anything.  This is great for testing writing code or
+     * doing dry runs.  When reading, it will produce NULL bytes, so any
+     * application that would like the ability to produce null streams as a
+     * snap-in replacement for any other Bu::Stream, this is the right option.
+     *
+     * As an added feature, the NullStream will track how many bytes it was
+     * asked to read and write, allowing you to use it to determine how many
+     * bytes a write opretion would use without actually writing anything.
+     */
+    class NullStream : public Bu::Stream
+    {
+    public:
+        NullStream();
+        virtual ~NullStream();
 
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::String readLine();
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Bu::Stream::write;
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::String readLine();
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Bu::Stream::write;
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
 
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-                Bu::size getBytesRead() { return sRead; }
-                Bu::size getByetsWritten() { return sWrote; }
+        Bu::size getBytesRead() { return sRead; }
+        Bu::size getByetsWritten() { return sWrote; }
 
-        private:
-                Bu::size sRead;
-                Bu::size sWrote;
-        };
+    private:
+        Bu::size sRead;
+        Bu::size sWrote;
+    };
 };
 
 #endif
diff --git a/src/stable/optparser.cpp b/src/stable/optparser.cpp
index 10a8fb6..aca36a2 100644
--- a/src/stable/optparser.cpp
+++ b/src/stable/optparser.cpp
@@ -21,168 +21,168 @@ Bu::OptParser::~OptParser()
 
 void Bu::OptParser::parse( int argc, char **argv )
 {
-        for( int j = 1; j < argc; j++ )
-        {
-                if( argv[j][0] == '-' )
-                {
-                        // Now we're on to something, which kind is it?
-                        if( argv[j][1] == '-' )
-                        {
-                                int iEPos;
-                                for( iEPos = 2; argv[j][iEPos] != '\0' &&
-                                         argv[j][iEPos] != '='; iEPos++ ) { }
-
-                                Bu::String sOpt;
-                                int iCount = argc-j;
-                                Bu::String sExtraParam;
-                                if( argv[j][iEPos] == '=' )
-                                {
-                                        sOpt.set( argv[j]+2, iEPos-2 );
-                                        iCount++;
-                                        sExtraParam.set( argv[j]+iEPos+1 );
-                                }
-                                else
-                                {
-                                        sOpt.set( argv[j]+2 );
-                                }
-                                if( !hlOption.has( sOpt ) )
-                                {
-                                        optionError( "--" + sOpt );
-                                }
-                                else
-                                {
-                                        // Long param, cool, that's easy, first search for =
-                                        Option *pOpt = hlOption.get( sOpt );
-                                        if( pOpt->sUsed )
-                                        {
-                                                Bu::StrArray aParams( iCount );
-                                                aParams.append( sOpt );
-                                                if( sExtraParam.isSet() )
-                                                {
-                                                        aParams.append( argv[j]+iEPos+1 );
-                                                }
-                                                for( int k = j+1; k < argc; k++ )
-                                                {
-                                                        aParams.append( argv[k] );
-                                                }
-                                                j += pOpt->sUsed( aParams );
-                                        }
-                                        else if( pOpt->pProxy )
-                                        {
-                                                if( pOpt->sOverride.isSet() )
-                                                {
-                                                        pOpt->pProxy->setValue( pOpt->sOverride );
-                                                }
-                                                else if( sExtraParam.isSet() )
-                                                {
-                                                        pOpt->pProxy->setValueFromStr( sExtraParam );
-                                                }
-                                                else if( argv[j+1] != '\0' )
-                                                {
-                                                        pOpt->pProxy->setValueFromStr( argv[j+1] );
-                                                        j++;
-                                                }
-                                        }
-                                }
-                        }
-                        else
-                        {
-                                int iCPos;
-                                for( iCPos = 1; argv[j][iCPos] != '\0'; iCPos++ )
-                                {
-                                        if( !hsOption.has( argv[j][iCPos] ) )
-                                        {
-                                                Bu::String sOpt("-");
-                                                sOpt += argv[j][iCPos];
-                                                optionError( sOpt );
-                                        }
-                                        else
-                                        {
-                                                Option *pOpt = hsOption.get( argv[j][iCPos] );
-                                                char buf[2] = {argv[j][iCPos], '\0'};
-                                                if( pOpt->sUsed )
-                                                {
-                                                        Bu::StrArray aParams( argc-j+1 );
-                                                        aParams.append( buf );
-                                                        int iMod = 0;
-                                                        if( argv[j][iCPos+1] != '\0' )
-                                                        {
-                                                                aParams.append( argv[j]+iCPos+1 );
-                                                                iMod = -1;
-                                                        }
-                                                        for( int k = j+1; k < argc; k++ )
-                                                        {
-                                                                aParams.append( argv[k] );
-                                                        }
-                                                        int iUsed = pOpt->sUsed( aParams );
-                                                        if( iUsed > 0 )
-                                                        {
-                                                                j += iUsed + iMod;
-                                                                break;
-                                                        }
-                                                }
-                                                else if( pOpt->pProxy )
-                                                {
-                                                        if( pOpt->sOverride.isSet() )
-                                                        {
-                                                                pOpt->pProxy->setValue( pOpt->sOverride );
-                                                        }
-                                                        else if( argv[j][iCPos+1] != '\0' )
-                                                        {
-                                                                pOpt->pProxy->setValueFromStr(
-                                                                        argv[j]+iCPos+1
-                                                                        );
-                                                                break;
-                                                        }
-                                                        else if( argv[j+1] )
-                                                        {
-                                                                pOpt->pProxy->setValueFromStr(
-                                                                        argv[j+1]
-                                                                        );
-                                                                j++;
-                                                                break;
-                                                        }
-                                                }
-                                        }
-                                }
-                        }
-                }
-                else
-                {
-                        if( !sNonOption )
-                        {
-                                optionError( argv[j] );
-                        }
-                        else
-                        {
-                                int iCount = argc-j;
-                                Bu::StrArray aParams( iCount );
-                                for( int k = j; k < argc; k++ )
-                                {
-                                        aParams.append( argv[k] );
-                                }
-                                j += sNonOption( aParams );
-                        }
-                }
-        }
+    for( int j = 1; j < argc; j++ )
+    {
+        if( argv[j][0] == '-' )
+        {
+            // Now we're on to something, which kind is it?
+            if( argv[j][1] == '-' )
+            {
+                int iEPos;
+                for( iEPos = 2; argv[j][iEPos] != '\0' &&
+                     argv[j][iEPos] != '='; iEPos++ ) { }
+
+                Bu::String sOpt;
+                int iCount = argc-j;
+                Bu::String sExtraParam;
+                if( argv[j][iEPos] == '=' )
+                {
+                    sOpt.set( argv[j]+2, iEPos-2 );
+                    iCount++;
+                    sExtraParam.set( argv[j]+iEPos+1 );
+                }
+                else
+                {
+                    sOpt.set( argv[j]+2 );
+                }
+                if( !hlOption.has( sOpt ) )
+                {
+                    optionError( "--" + sOpt );
+                }
+                else
+                {
+                    // Long param, cool, that's easy, first search for =
+                    Option *pOpt = hlOption.get( sOpt );
+                    if( pOpt->sUsed )
+                    {
+                        Bu::StrArray aParams( iCount );
+                        aParams.append( sOpt );
+                        if( sExtraParam.isSet() )
+                        {
+                            aParams.append( argv[j]+iEPos+1 );
+                        }
+                        for( int k = j+1; k < argc; k++ )
+                        {
+                            aParams.append( argv[k] );
+                        }
+                        j += pOpt->sUsed( aParams );
+                    }
+                    else if( pOpt->pProxy )
+                    {
+                        if( pOpt->sOverride.isSet() )
+                        {
+                            pOpt->pProxy->setValue( pOpt->sOverride );
+                        }
+                        else if( sExtraParam.isSet() )
+                        {
+                            pOpt->pProxy->setValueFromStr( sExtraParam );
+                        }
+                        else if( argv[j+1] != '\0' )
+                        {
+                            pOpt->pProxy->setValueFromStr( argv[j+1] );
+                            j++;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                int iCPos;
+                for( iCPos = 1; argv[j][iCPos] != '\0'; iCPos++ )
+                {
+                    if( !hsOption.has( argv[j][iCPos] ) )
+                    {
+                        Bu::String sOpt("-");
+                        sOpt += argv[j][iCPos];
+                        optionError( sOpt );
+                    }
+                    else
+                    {
+                        Option *pOpt = hsOption.get( argv[j][iCPos] );
+                        char buf[2] = {argv[j][iCPos], '\0'};
+                        if( pOpt->sUsed )
+                        {
+                            Bu::StrArray aParams( argc-j+1 );
+                            aParams.append( buf );
+                            int iMod = 0;
+                            if( argv[j][iCPos+1] != '\0' )
+                            {
+                                aParams.append( argv[j]+iCPos+1 );
+                                iMod = -1;
+                            }
+                            for( int k = j+1; k < argc; k++ )
+                            {
+                                aParams.append( argv[k] );
+                            }
+                            int iUsed = pOpt->sUsed( aParams );
+                            if( iUsed > 0 )
+                            {
+                                j += iUsed + iMod;
+                                break;
+                            }
+                        }
+                        else if( pOpt->pProxy )
+                        {
+                            if( pOpt->sOverride.isSet() )
+                            {
+                                pOpt->pProxy->setValue( pOpt->sOverride );
+                            }
+                            else if( argv[j][iCPos+1] != '\0' )
+                            {
+                                pOpt->pProxy->setValueFromStr(
+                                    argv[j]+iCPos+1
+                                    );
+                                break;
+                            }
+                            else if( argv[j+1] )
+                            {
+                                pOpt->pProxy->setValueFromStr(
+                                    argv[j+1]
+                                    );
+                                j++;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else
+        {
+            if( !sNonOption )
+            {
+                optionError( argv[j] );
+            }
+            else
+            {
+                int iCount = argc-j;
+                Bu::StrArray aParams( iCount );
+                for( int k = j; k < argc; k++ )
+                {
+                    aParams.append( argv[k] );
+                }
+                j += sNonOption( aParams );
+            }
+        }
+    }
 }
 
 void Bu::OptParser::parse( const Bu::String &sLine )
 {
-        Bu::String sCmd = sLine.clone();
-        int iParams = 0;
-        bool bInGap = true;
-        bool bInQuote = false;
-        for( Bu::String::iterator i = sCmd.begin(); i; i++ )
-        {
-                if( bInQuote == false && (*i == ' ' || *i == '\t') )
-                {
-                        if( bInGap == false )
-                        {
-                                bInGap = true;
-                        }
-                }
-                else if( *i == '"' )
+    Bu::String sCmd = sLine.clone();
+    int iParams = 0;
+    bool bInGap = true;
+    bool bInQuote = false;
+    for( Bu::String::iterator i = sCmd.begin(); i; i++ )
+    {
+        if( bInQuote == false && (*i == ' ' || *i == '\t') )
+        {
+            if( bInGap == false )
+            {
+                bInGap = true;
+            }
+        }
+        else if( *i == '"' )
                 {
                         bInQuote = !bInQuote;
                 }
@@ -211,242 +211,242 @@ void Bu::OptParser::parse( const Bu::String &sLine )
                         }
                 }
                 else if( *i == '"' )
-                {
-                        bInQuote = !bInQuote;
-                }
-                else
-                {
-                        if( bInGap )
-                        {
-                                asParam[iParams++] = i;
-                                bInGap = false;
-                        }
-                }
-        }
-
-        parse( iParams, asParam );
-
-        delete[] asParam;
+        {
+            bInQuote = !bInQuote;
+        }
+        else
+        {
+            if( bInGap )
+            {
+                asParam[iParams++] = i;
+                bInGap = false;
+            }
+        }
+    }
+
+    parse( iParams, asParam );
+
+    delete[] asParam;
 }
 
 void Bu::OptParser::addOption( const Option &opt )
 {
-        lOption.append( opt );
-        if( opt.cOpt != '\0' )
-                hsOption.insert( opt.cOpt, &lOption.last() );
-        if( opt.sOpt.isSet() )
-                hlOption.insert( opt.sOpt, &lOption.last() );
+    lOption.append( opt );
+    if( opt.cOpt != '\0' )
+        hsOption.insert( opt.cOpt, &lOption.last() );
+    if( opt.sOpt.isSet() )
+        hlOption.insert( opt.sOpt, &lOption.last() );
 }
 
 void Bu::OptParser::setOverride( char cOpt, const Bu::Variant &sOverride )
 {
-        hsOption.get( cOpt )->sOverride = sOverride;
+    hsOption.get( cOpt )->sOverride = sOverride;
 }
 
 void Bu::OptParser::setOverride( const Bu::String &sOpt, const Bu::Variant &sOverride )
 {
-        hlOption.get( sOpt )->sOverride = sOverride;
+    hlOption.get( sOpt )->sOverride = sOverride;
 }
 
 void Bu::OptParser::setHelpDefault( const Bu::String &sOpt, const Bu::String &sTxt )
 {
-        hlOption.get( sOpt )->sHelpDefault = sTxt;
+    hlOption.get( sOpt )->sHelpDefault = sTxt;
 }
 
 void Bu::OptParser::addHelpOption( char c, const Bu::String &s, const Bu::String &sHelp )
 {
-        Option o;
-        o.sUsed = slot( this, &OptParser::optHelp );
-        o.cOpt = c;
-        o.sOpt = s;
-        o.sHelp = sHelp;
-        addOption( o );
+    Option o;
+    o.sUsed = slot( this, &OptParser::optHelp );
+    o.cOpt = c;
+    o.sOpt = s;
+    o.sHelp = sHelp;
+    addOption( o );
 }
 
 void Bu::OptParser::addHelpBanner( const Bu::String &sText, bool bFormatted )
 {
-        Banner b;
-        b.sText = sText;
-        b.bFormatted = bFormatted;
-        if( lOption.getSize() > 0 )
-        {
-                for( b.iAfter = lOption.begin(); b.iAfter+1; b.iAfter++ ) { }
-        }
-        lBanner.append( b );
+    Banner b;
+    b.sText = sText;
+    b.bFormatted = bFormatted;
+    if( lOption.getSize() > 0 )
+    {
+        for( b.iAfter = lOption.begin(); b.iAfter+1; b.iAfter++ ) { }
+    }
+    lBanner.append( b );
 }
 
 int Bu::OptParser::optHelp( StrArray /*aParams*/ )
 {
-        bool bHasShort = false;
-        int iMaxWidth = 0;
-        int iScrWidth = 80;
-        char *env = getenv("COLUMNS");
-        if( env )
-                iScrWidth = strtol( env, NULL, 10 );
-        for( OptionList::iterator i = lOption.begin(); i; i++ )
-        {
-                if( (*i).cOpt != '\0' )
-                        bHasShort = true;
-                int lOptSize = (*i).sOpt.getSize() + (*i).sHelpDefault.getSize();
-                if( (*i).sOpt.isSet() && iMaxWidth < lOptSize )
-                        iMaxWidth = lOptSize;
-        }
-        int iIndent = 4;
-        if( bHasShort )
-                iIndent += 4;
-        if( iMaxWidth > 0 )
-                iIndent += 4 + iMaxWidth;
-
-        BannerList::iterator iBanner;
-        for( iBanner = lBanner.begin(); iBanner; iBanner++ )
-        {
-                if( (*iBanner).iAfter )
-                        break;
-
-                if( (*iBanner).bFormatted )
-                        sio << format( (*iBanner).sText, iScrWidth-1, 0 );
-                else
-                        sio << (*iBanner).sText;
-                sio << sio.nl;
-        }
-        for( OptionList::iterator i = lOption.begin(); i; i++ )
-        {
-                sio << "    ";
-                if( bHasShort )
-                {
-                        if( (*i).cOpt == '\0' )
-                                sio << "  ";
-                        else
-                                sio << "-" << (*i).cOpt;
-                        sio << "  ";
-                }
-                if( iMaxWidth > 0 )
-                {
-                        if( (*i).sOpt.isSet() )
-                        {
-                                sio << "--" << Fmt(iMaxWidth, Fmt::Left)
-                                        << (*i).sOpt + (*i).sHelpDefault;
-                        }
-                        else
-                        {
-                                sio << "  " << Fmt(iMaxWidth) << "";
-                        }
-                        sio << "  ";
-                }
-                sio << format( (*i).sHelp, iScrWidth-iIndent-1, iIndent );
-                sio << sio.nl;
-        
-                for( ; iBanner; iBanner++ )
-                {
-                        if( (*iBanner).iAfter != i )
-                                break;
-                        
-                        if( (*iBanner).bFormatted )
-                                sio << format( (*iBanner).sText, iScrWidth-1, 0 );
-                        else
-                                sio << (*iBanner).sText;
-                        sio << sio.nl;
-                }
-        }
-        exit( 0 );
-        return 0;
+    bool bHasShort = false;
+    int iMaxWidth = 0;
+    int iScrWidth = 80;
+    char *env = getenv("COLUMNS");
+    if( env )
+        iScrWidth = strtol( env, NULL, 10 );
+    for( OptionList::iterator i = lOption.begin(); i; i++ )
+    {
+        if( (*i).cOpt != '\0' )
+            bHasShort = true;
+        int lOptSize = (*i).sOpt.getSize() + (*i).sHelpDefault.getSize();
+        if( (*i).sOpt.isSet() && iMaxWidth < lOptSize )
+            iMaxWidth = lOptSize;
+    }
+    int iIndent = 4;
+    if( bHasShort )
+        iIndent += 4;
+    if( iMaxWidth > 0 )
+        iIndent += 4 + iMaxWidth;
+
+    BannerList::iterator iBanner;
+    for( iBanner = lBanner.begin(); iBanner; iBanner++ )
+    {
+        if( (*iBanner).iAfter )
+            break;
+
+        if( (*iBanner).bFormatted )
+            sio << format( (*iBanner).sText, iScrWidth-1, 0 );
+        else
+            sio << (*iBanner).sText;
+        sio << sio.nl;
+    }
+    for( OptionList::iterator i = lOption.begin(); i; i++ )
+    {
+        sio << "    ";
+        if( bHasShort )
+        {
+            if( (*i).cOpt == '\0' )
+                sio << "  ";
+            else
+                sio << "-" << (*i).cOpt;
+            sio << "  ";
+        }
+        if( iMaxWidth > 0 )
+        {
+            if( (*i).sOpt.isSet() )
+            {
+                sio << "--" << Fmt(iMaxWidth, Fmt::Left)
+                    << (*i).sOpt + (*i).sHelpDefault;
+            }
+            else
+            {
+                sio << "  " << Fmt(iMaxWidth) << "";
+            }
+            sio << "  ";
+        }
+        sio << format( (*i).sHelp, iScrWidth-iIndent-1, iIndent );
+        sio << sio.nl;
+    
+        for( ; iBanner; iBanner++ )
+        {
+            if( (*iBanner).iAfter != i )
+                break;
+            
+            if( (*iBanner).bFormatted )
+                sio << format( (*iBanner).sText, iScrWidth-1, 0 );
+            else
+                sio << (*iBanner).sText;
+            sio << sio.nl;
+        }
+    }
+    exit( 0 );
+    return 0;
 }
 
 void Bu::OptParser::optionError( const Bu::String &sOption )
 {
-        sio << "Unregcognized option discovered: " << sOption << sio.nl << sio.nl;
-        exit( 1 );
+    sio << "Unregcognized option discovered: " << sOption << sio.nl << sio.nl;
+    exit( 1 );
 }
 
 void Bu::OptParser::setNonOption( OptionSignal sSignal )
 {
-        sNonOption = sSignal;
+    sNonOption = sSignal;
 }
 
 Bu::String Bu::OptParser::format( const Bu::String &sIn, int iWidth,
-                int iIndent )
+        int iIndent )
 {
-        Bu::String sOut;
-        Bu::String sIndent;
-        for( int j = 0; j < iIndent; j++ )
-                sIndent.append(" ", 1);
-        bool bFirst = true;
-        int iSpaceCount = 0;
-        bool bSpace = false;
-        int iPrevLineLen;
-        int iLineLen = 0;
-        Bu::String::const_iterator iLastSpace, iStart;
-        for( Bu::String::const_iterator i = iLastSpace = iStart = sIn.begin(); i; i++ )
-        {
-                if( *i == ' ' )
-                {
-                        if( bSpace == false )
-                        {
-                                iLastSpace = i;
-                                iSpaceCount++;
-                                bSpace = true;
-                                iPrevLineLen = iLineLen;
-                        }
-                }
-                else
-                {
-                        bSpace = false;
-                }
-                iLineLen++;
-
-                if( iLineLen >= iWidth )
-                {
-                        iSpaceCount--;
-                        if( bFirst == true )
-                                bFirst = false;
-                        else
-                                sOut += sIndent;
-                        int iExtraSpaces = iWidth-iPrevLineLen;
-                        bSpace = false;
-                        float fFill = 0.0;
-                        int iSubSpaceCount = 0;
-                        float fAdd = ((float)iExtraSpaces/(float)iSpaceCount);
-                        for( Bu::String::const_iterator k = iStart; k != iLastSpace; k++ )
-                        {
-                                sOut += *k;
-                                if( *k == ' ' )
-                                {
-                                        if( bSpace == false && iExtraSpaces > 0 )
-                                        {
-                                                bSpace = true;
-                                                fFill += fAdd;
-                                                iSubSpaceCount++;
-                                                for( int sp = 0; sp < (int)(fFill); sp++ )
-                                                {
-                                                        sOut += ' ';
-                                                        iExtraSpaces--;
-                                                }
-                                                fFill -= (int)fFill;
-                                                if( iSubSpaceCount == iSpaceCount && iExtraSpaces > 0 )
-                                                {
-                                                        for(; iExtraSpaces > 0; iExtraSpaces-- )
-                                                        {
-                                                                sOut += ' ';
-                                                        }
-                                                }
-                                        }
-                                }
-                                else
-                                        bSpace = false;
-                        }
-                        //sOut.append( iStart, iLastSpace );
-                        sOut.append("\n");
-                        for(; iLastSpace && *iLastSpace == ' '; iLastSpace++ ) { }
-                        iStart = i = iLastSpace;
-                        bSpace = false;
-                        iLineLen = 1;
-                        iSpaceCount = 0;
-                }
-        }
-        if( !bFirst )
-                sOut += sIndent;
-        sOut.append( iStart );
-        return sOut;
+    Bu::String sOut;
+    Bu::String sIndent;
+    for( int j = 0; j < iIndent; j++ )
+        sIndent.append(" ", 1);
+    bool bFirst = true;
+    int iSpaceCount = 0;
+    bool bSpace = false;
+    int iPrevLineLen;
+    int iLineLen = 0;
+    Bu::String::const_iterator iLastSpace, iStart;
+    for( Bu::String::const_iterator i = iLastSpace = iStart = sIn.begin(); i; i++ )
+    {
+        if( *i == ' ' )
+        {
+            if( bSpace == false )
+            {
+                iLastSpace = i;
+                iSpaceCount++;
+                bSpace = true;
+                iPrevLineLen = iLineLen;
+            }
+        }
+        else
+        {
+            bSpace = false;
+        }
+        iLineLen++;
+
+        if( iLineLen >= iWidth )
+        {
+            iSpaceCount--;
+            if( bFirst == true )
+                bFirst = false;
+            else
+                sOut += sIndent;
+            int iExtraSpaces = iWidth-iPrevLineLen;
+            bSpace = false;
+            float fFill = 0.0;
+            int iSubSpaceCount = 0;
+            float fAdd = ((float)iExtraSpaces/(float)iSpaceCount);
+            for( Bu::String::const_iterator k = iStart; k != iLastSpace; k++ )
+            {
+                sOut += *k;
+                if( *k == ' ' )
+                {
+                    if( bSpace == false && iExtraSpaces > 0 )
+                    {
+                        bSpace = true;
+                        fFill += fAdd;
+                        iSubSpaceCount++;
+                        for( int sp = 0; sp < (int)(fFill); sp++ )
+                        {
+                            sOut += ' ';
+                            iExtraSpaces--;
+                        }
+                        fFill -= (int)fFill;
+                        if( iSubSpaceCount == iSpaceCount && iExtraSpaces > 0 )
+                        {
+                            for(; iExtraSpaces > 0; iExtraSpaces-- )
+                            {
+                                sOut += ' ';
+                            }
+                        }
+                    }
+                }
+                else
+                    bSpace = false;
+            }
+            //sOut.append( iStart, iLastSpace );
+            sOut.append("\n");
+            for(; iLastSpace && *iLastSpace == ' '; iLastSpace++ ) { }
+            iStart = i = iLastSpace;
+            bSpace = false;
+            iLineLen = 1;
+            iSpaceCount = 0;
+        }
+    }
+    if( !bFirst )
+        sOut += sIndent;
+    sOut.append( iStart );
+    return sOut;
 }
 
 
@@ -467,26 +467,26 @@ Bu::OptParser::_ValueProxy::~_ValueProxy()
 //
 
 Bu::OptParser::Option::Option() :
-        cOpt( '\0' ),
-        pProxy( NULL )
+    cOpt( '\0' ),
+    pProxy( NULL )
 {
 }
 
 Bu::OptParser::Option::Option( const Option &rSrc ) :
-        cOpt( rSrc.cOpt ),
-        sOpt( rSrc.sOpt ),
-        sHelp( rSrc.sHelp ),
-        sUsed( rSrc.sUsed ),
-        pProxy( NULL ),
-        sOverride( rSrc.sOverride )
+    cOpt( rSrc.cOpt ),
+    sOpt( rSrc.sOpt ),
+    sHelp( rSrc.sHelp ),
+    sUsed( rSrc.sUsed ),
+    pProxy( NULL ),
+    sOverride( rSrc.sOverride )
 {
-        if( rSrc.pProxy )
-                pProxy = rSrc.pProxy->clone();
+    if( rSrc.pProxy )
+        pProxy = rSrc.pProxy->clone();
 }
 
 Bu::OptParser::Option::~Option()
 {
-        delete pProxy;
-        pProxy = NULL;
+    delete pProxy;
+    pProxy = NULL;
 }
 
diff --git a/src/stable/optparser.h b/src/stable/optparser.h
index 2da93c9..412f262 100644
--- a/src/stable/optparser.h
+++ b/src/stable/optparser.h
@@ -19,205 +19,205 @@
 
 namespace Bu
 {
-        typedef Bu::Array<Bu::String> StrArray;
-
-        /**
-         * POSIX/Gnu style command line parser.  Handles long and short options in
-         * a variety of fun and useful ways, along with singal based callbacks and
-         * automatic variable setting.  It's pretty easy to use, and very flexible.
-         *
-         * OptParser supports it's own builtin help mechanism which automatically
-         * enumerates the available options and their help in a well formatted and
-         * easy to read way, automatically formatting your help text per option and
-         * allows for addition "help banners" which can be placed wherever you
-         * would like.
-         */
-        class OptParser
-        {
-        private:
-                class _ValueProxy
-                {
-                public:
-                        _ValueProxy();
-                        virtual ~_ValueProxy();
-
-                        virtual void setValueFromStr( const Bu::String & )=0;
-                        virtual void setValue( const Bu::Variant &vVar )=0;
-                        virtual _ValueProxy *clone()=0;
-                };
-
-                template<typename ptype>
-                class ValueProxy : public _ValueProxy
-                {
-                public:
-                        ValueProxy( ptype &v ) :
-                                v( v )
-                        {
-                        }
-
-                        virtual ~ValueProxy()
-                        {
-                        }
-
-                        virtual void setValueFromStr( const Bu::String &sVal )
-                        {
-                                Bu::MemBuf mb( sVal );
-                                Bu::Formatter f( mb );
-                                f << Bu::Fmt().tokenize( false );
-                                f >> v;
-                        }
-
-                        virtual void setValue( const Bu::Variant &vVar )
-                        {
-                                if( vVar.getType() == typeid(ptype) )
-                                {
-                                        v = vVar.get<ptype>();
-                                }
-                                else if( vVar.getType() == typeid(Bu::String) )
-                                {
-                                        setValueFromStr( vVar.get<Bu::String>() );
-                                }
-                                else
-                                {
-                                        Bu::MemBuf mb;
-                                        Bu::Formatter f( mb );
-//                                      f << vVar;
-                                        setValueFromStr( mb.getString() );
-                                }
-                        }
-                        
-                        virtual _ValueProxy *clone()
-                        {
-                                return new ValueProxy<ptype>( v );
-                        }
-
-                private:
-                        ptype &v;
-                };
-
-        public:
-                typedef Signal1<int, StrArray> OptionSignal;
-                class Option
-                {
-                public:
-                        Option();
-                        Option( const Option &rSrc );
-                        virtual ~Option();
-
-                        char cOpt;
-                        Bu::String sOpt;
-                        Bu::String sHelp;
-                        OptionSignal sUsed;
-                        _ValueProxy *pProxy;
-                        Bu::Variant sOverride;
-                        Bu::String sHelpDefault;
-                };
-        
-        private:
-                typedef Bu::List<Option> OptionList;
-                typedef Bu::Hash<char, Option *> ShortOptionHash;
-                typedef Bu::Hash<Bu::String, Option *> LongOptionHash;
-                
-                class Banner
-                {
-                public:
-                        Bu::String sText;
-                        bool bFormatted;
-                        OptionList::const_iterator iAfter;
-                };
-
-                typedef Bu::List<Banner> BannerList;
-
-        public:
-                OptParser();
-                virtual ~OptParser();
-
-                void parse( int argc, char **argv );
-                void parse( const Bu::String &sLine );
-
-                void addOption( const Option &opt );
-                
-                template<typename vtype>
-                void addOption( vtype &var, char cOpt, const Bu::String &sOpt,
-                                const Bu::String &sHelp )
-                {
-                        Option o;
-                        o.cOpt = cOpt;
-                        o.sOpt = sOpt;
-                        o.pProxy = new ValueProxy<vtype>( var );
-                        o.sHelp = sHelp;
-                        addOption( o );
-                }
-                
-                template<typename vtype>
-                void addOption( vtype &var, const Bu::String &sOpt,
-                                const Bu::String &sHelp )
-                {
-                        addOption( var, '\0', sOpt, sHelp );
-                }
-                
-                template<typename vtype>
-                void addOption( vtype &var, char cOpt, const Bu::String &sHelp )
-                {
-                        addOption( var, cOpt, "", sHelp );
-                }
-
-                void addOption( OptionSignal sUsed, char cOpt, const Bu::String &sOpt,
-                                const Bu::String &sHelp )
-                {
-                        Option o;
-                        o.cOpt = cOpt;
-                        o.sOpt = sOpt;
-                        o.sUsed = sUsed;
-                        o.sHelp = sHelp;
-                        addOption( o );
-                }
-                
-                void addOption( OptionSignal sUsed, const Bu::String &sOpt,
-                                const Bu::String &sHelp )
-                {
-                        addOption( sUsed, '\0', sOpt, sHelp );
-                }
-                
-                void addOption( OptionSignal sUsed, char cOpt,
-                                const Bu::String &sHelp )
-                {
-                        addOption( sUsed, cOpt, "", sHelp );
-                }
-
-                void setOverride( char cOpt, const Bu::Variant &sOverride );
-                void setOverride( const Bu::String &sOpt,
-                                const Bu::Variant &sOverride );
-
-                void setHelpDefault( const Bu::String &sOpt, const Bu::String &sTxt );
-                
-                void addHelpOption( char c='h', const Bu::String &s="help",
-                                const Bu::String &sHelp="This help." );
-                void addHelpBanner( const Bu::String &sText, bool bFormatted=true );
-
-                int optHelp( StrArray aParams );
-
-                /**
-                 * This function is called when an unrecognized option is found, the
-                 * default behaviour is to print an error to stdout and exit( 1 ), if
-                 * you want to do something different, just override this function.
-                 * This is also called by default when something is found that hasn't
-                 * been handled by an option, and isn't an option (starts with - or --).
-                 * To change this behaviour call 
-                 */
-                virtual void optionError( const Bu::String &sOption );
-
-                void setNonOption( OptionSignal sSignal );
-
-        private:
-                Bu::String format( const Bu::String &sIn, int iWidth, int iIndent );
-
-                OptionList lOption;
-                ShortOptionHash hsOption;
-                LongOptionHash hlOption;
-                BannerList lBanner;
-                OptionSignal sNonOption;
-        };
+    typedef Bu::Array<Bu::String> StrArray;
+
+    /**
+     * POSIX/Gnu style command line parser.  Handles long and short options in
+     * a variety of fun and useful ways, along with singal based callbacks and
+     * automatic variable setting.  It's pretty easy to use, and very flexible.
+     *
+     * OptParser supports it's own builtin help mechanism which automatically
+     * enumerates the available options and their help in a well formatted and
+     * easy to read way, automatically formatting your help text per option and
+     * allows for addition "help banners" which can be placed wherever you
+     * would like.
+     */
+    class OptParser
+    {
+    private:
+        class _ValueProxy
+        {
+        public:
+            _ValueProxy();
+            virtual ~_ValueProxy();
+
+            virtual void setValueFromStr( const Bu::String & )=0;
+            virtual void setValue( const Bu::Variant &vVar )=0;
+            virtual _ValueProxy *clone()=0;
+        };
+
+        template<typename ptype>
+        class ValueProxy : public _ValueProxy
+        {
+        public:
+            ValueProxy( ptype &v ) :
+                v( v )
+            {
+            }
+
+            virtual ~ValueProxy()
+            {
+            }
+
+            virtual void setValueFromStr( const Bu::String &sVal )
+            {
+                Bu::MemBuf mb( sVal );
+                Bu::Formatter f( mb );
+                f << Bu::Fmt().tokenize( false );
+                f >> v;
+            }
+
+            virtual void setValue( const Bu::Variant &vVar )
+            {
+                if( vVar.getType() == typeid(ptype) )
+                {
+                    v = vVar.get<ptype>();
+                }
+                else if( vVar.getType() == typeid(Bu::String) )
+                {
+                    setValueFromStr( vVar.get<Bu::String>() );
+                }
+                else
+                {
+                    Bu::MemBuf mb;
+                    Bu::Formatter f( mb );
+//                  f << vVar;
+                    setValueFromStr( mb.getString() );
+                }
+            }
+            
+            virtual _ValueProxy *clone()
+            {
+                return new ValueProxy<ptype>( v );
+            }
+
+        private:
+            ptype &v;
+        };
+
+    public:
+        typedef Signal1<int, StrArray> OptionSignal;
+        class Option
+        {
+        public:
+            Option();
+            Option( const Option &rSrc );
+            virtual ~Option();
+
+            char cOpt;
+            Bu::String sOpt;
+            Bu::String sHelp;
+            OptionSignal sUsed;
+            _ValueProxy *pProxy;
+            Bu::Variant sOverride;
+            Bu::String sHelpDefault;
+        };
+    
+    private:
+        typedef Bu::List<Option> OptionList;
+        typedef Bu::Hash<char, Option *> ShortOptionHash;
+        typedef Bu::Hash<Bu::String, Option *> LongOptionHash;
+        
+        class Banner
+        {
+        public:
+            Bu::String sText;
+            bool bFormatted;
+            OptionList::const_iterator iAfter;
+        };
+
+        typedef Bu::List<Banner> BannerList;
+
+    public:
+        OptParser();
+        virtual ~OptParser();
+
+        void parse( int argc, char **argv );
+        void parse( const Bu::String &sLine );
+
+        void addOption( const Option &opt );
+        
+        template<typename vtype>
+        void addOption( vtype &var, char cOpt, const Bu::String &sOpt,
+                const Bu::String &sHelp )
+        {
+            Option o;
+            o.cOpt = cOpt;
+            o.sOpt = sOpt;
+            o.pProxy = new ValueProxy<vtype>( var );
+            o.sHelp = sHelp;
+            addOption( o );
+        }
+        
+        template<typename vtype>
+        void addOption( vtype &var, const Bu::String &sOpt,
+                const Bu::String &sHelp )
+        {
+            addOption( var, '\0', sOpt, sHelp );
+        }
+        
+        template<typename vtype>
+        void addOption( vtype &var, char cOpt, const Bu::String &sHelp )
+        {
+            addOption( var, cOpt, "", sHelp );
+        }
+
+        void addOption( OptionSignal sUsed, char cOpt, const Bu::String &sOpt,
+                const Bu::String &sHelp )
+        {
+            Option o;
+            o.cOpt = cOpt;
+            o.sOpt = sOpt;
+            o.sUsed = sUsed;
+            o.sHelp = sHelp;
+            addOption( o );
+        }
+        
+        void addOption( OptionSignal sUsed, const Bu::String &sOpt,
+                const Bu::String &sHelp )
+        {
+            addOption( sUsed, '\0', sOpt, sHelp );
+        }
+        
+        void addOption( OptionSignal sUsed, char cOpt,
+                const Bu::String &sHelp )
+        {
+            addOption( sUsed, cOpt, "", sHelp );
+        }
+
+        void setOverride( char cOpt, const Bu::Variant &sOverride );
+        void setOverride( const Bu::String &sOpt,
+                const Bu::Variant &sOverride );
+
+        void setHelpDefault( const Bu::String &sOpt, const Bu::String &sTxt );
+        
+        void addHelpOption( char c='h', const Bu::String &s="help",
+                const Bu::String &sHelp="This help." );
+        void addHelpBanner( const Bu::String &sText, bool bFormatted=true );
+
+        int optHelp( StrArray aParams );
+
+        /**
+         * This function is called when an unrecognized option is found, the
+         * default behaviour is to print an error to stdout and exit( 1 ), if
+         * you want to do something different, just override this function.
+         * This is also called by default when something is found that hasn't
+         * been handled by an option, and isn't an option (starts with - or --).
+         * To change this behaviour call 
+         */
+        virtual void optionError( const Bu::String &sOption );
+
+        void setNonOption( OptionSignal sSignal );
+
+    private:
+        Bu::String format( const Bu::String &sIn, int iWidth, int iIndent );
+
+        OptionList lOption;
+        ShortOptionHash hsOption;
+        LongOptionHash hlOption;
+        BannerList lBanner;
+        OptionSignal sNonOption;
+    };
 };
 
 #endif
diff --git a/src/stable/pearsonhash.cpp b/src/stable/pearsonhash.cpp
index d4e82df..6f58470 100644
--- a/src/stable/pearsonhash.cpp
+++ b/src/stable/pearsonhash.cpp
@@ -9,28 +9,28 @@
 #include "bu/stream.h"
 
 uint8_t Bu::PearsonHash::aSBox[] = {
-        251, 175, 119, 215, 81, 14, 79, 191, 103, 49, 181, 143, 186, 157, 0,
-        232, 31, 32, 55, 60, 152, 58, 17, 237, 174, 70, 160, 144, 220, 90, 57,
-        223, 59, 3, 18, 140, 111, 166, 203, 196, 134, 243, 124, 95, 222, 179,
-        197, 65, 180, 48, 36, 15, 107, 46, 233, 130, 165, 30, 123, 161, 209, 23,
-        97, 16, 40, 91, 219, 61, 100, 10, 210, 109, 250, 127, 22, 138, 29, 108,
-        244, 67, 207, 9, 178, 204, 74, 98, 126, 249, 167, 116, 34, 77, 193,
-        200, 121, 5, 20, 113, 71, 35, 128, 13, 182, 94, 25, 226, 227, 199, 75,
-        27, 41, 245, 230, 224, 43, 225, 177, 26, 155, 150, 212, 142, 218, 115,
-        241, 73, 88, 105, 39, 114, 62, 255, 192, 201, 145, 214, 168, 158, 221,
-        148, 154, 122, 12, 84, 82, 163, 44, 139, 228, 236, 205, 242, 217, 11,
-        187, 146, 159, 64, 86, 239, 195, 42, 106, 198, 118, 112, 184, 172, 87,
-        2, 173, 117, 176, 229, 247, 253, 137, 185, 99, 164, 102, 147, 45, 66,
-        231, 52, 141, 211, 194, 206, 246, 238, 56, 110, 78, 248, 63, 240, 189,
-        93, 92, 51, 53, 183, 19, 171, 72, 50, 33, 104, 101, 69, 8, 252, 83, 120,
-        76, 135, 85, 54, 202, 125, 188, 213, 96, 235, 136, 208, 162, 129, 190,
-        132, 156, 38, 47, 1, 7, 254, 24, 4, 216, 131, 89, 21, 28, 133, 37, 153,
-        149, 80, 170, 68, 6, 169, 234, 151
+    251, 175, 119, 215, 81, 14, 79, 191, 103, 49, 181, 143, 186, 157, 0,
+    232, 31, 32, 55, 60, 152, 58, 17, 237, 174, 70, 160, 144, 220, 90, 57,
+    223, 59, 3, 18, 140, 111, 166, 203, 196, 134, 243, 124, 95, 222, 179,
+    197, 65, 180, 48, 36, 15, 107, 46, 233, 130, 165, 30, 123, 161, 209, 23,
+    97, 16, 40, 91, 219, 61, 100, 10, 210, 109, 250, 127, 22, 138, 29, 108,
+    244, 67, 207, 9, 178, 204, 74, 98, 126, 249, 167, 116, 34, 77, 193,
+    200, 121, 5, 20, 113, 71, 35, 128, 13, 182, 94, 25, 226, 227, 199, 75,
+    27, 41, 245, 230, 224, 43, 225, 177, 26, 155, 150, 212, 142, 218, 115,
+    241, 73, 88, 105, 39, 114, 62, 255, 192, 201, 145, 214, 168, 158, 221,
+    148, 154, 122, 12, 84, 82, 163, 44, 139, 228, 236, 205, 242, 217, 11,
+    187, 146, 159, 64, 86, 239, 195, 42, 106, 198, 118, 112, 184, 172, 87,
+    2, 173, 117, 176, 229, 247, 253, 137, 185, 99, 164, 102, 147, 45, 66,
+    231, 52, 141, 211, 194, 206, 246, 238, 56, 110, 78, 248, 63, 240, 189,
+    93, 92, 51, 53, 183, 19, 171, 72, 50, 33, 104, 101, 69, 8, 252, 83, 120,
+    76, 135, 85, 54, 202, 125, 188, 213, 96, 235, 136, 208, 162, 129, 190,
+    132, 156, 38, 47, 1, 7, 254, 24, 4, 216, 131, 89, 21, 28, 133, 37, 153,
+    149, 80, 170, 68, 6, 169, 234, 151
 };
 
 Bu::PearsonHash::PearsonHash()
 {
-        reset();
+    reset();
 }
 
 Bu::PearsonHash::~PearsonHash()
@@ -39,7 +39,7 @@ Bu::PearsonHash::~PearsonHash()
 
 void Bu::PearsonHash::reset()
 {
-        iValue = 0;
+    iValue = 0;
 }
 
 void Bu::PearsonHash::setSalt( const Bu::String & /*sSalt*/ )
@@ -48,19 +48,19 @@ void Bu::PearsonHash::setSalt( const Bu::String & /*sSalt*/ )
 
 void Bu::PearsonHash::addData( const void *sData, int iSize )
 {
-        for( int j = 0; j < iSize; j++ )
-        {
-                iValue = aSBox[ iValue^((unsigned char *)sData)[j] ];
-        }
+    for( int j = 0; j < iSize; j++ )
+    {
+        iValue = aSBox[ iValue^((unsigned char *)sData)[j] ];
+    }
 }
 
 Bu::String Bu::PearsonHash::getResult()
 {
-        return Bu::String((char)iValue);
+    return Bu::String((char)iValue);
 }
 
 void Bu::PearsonHash::writeResult( Stream &sOut )
 {
-        sOut.write( &iValue, 1 );
+    sOut.write( &iValue, 1 );
 }
 
diff --git a/src/stable/pearsonhash.h b/src/stable/pearsonhash.h
index ca377c1..ece1d40 100644
--- a/src/stable/pearsonhash.h
+++ b/src/stable/pearsonhash.h
@@ -12,35 +12,35 @@
 
 namespace Bu
 {
-        /**
-         * A pearson hash is a non-cryptographically secure hashing function that
-         * is very light on resources, very fast, and produces a single byte
-         * as it's output.  It is strongly dependant on every byte in the input,
-         * which means that it's a good choice for adding to short messages to
-         * ensure that the contents of the messages are unchanged.
-         *
-         * Pearson hash is named for it's inventor Peter K. Pearson who described
-         * it in his article "Fast hashing of variable-length text strings"
-         * published in 1990 by ACM.  I haven't read it, because you have to pay to
-         * get a copy :-P
-         */
-        class PearsonHash : public Bu::CryptoHash
-        {
-        public:
-                PearsonHash();
-                virtual ~PearsonHash();
+    /**
+     * A pearson hash is a non-cryptographically secure hashing function that
+     * is very light on resources, very fast, and produces a single byte
+     * as it's output.  It is strongly dependant on every byte in the input,
+     * which means that it's a good choice for adding to short messages to
+     * ensure that the contents of the messages are unchanged.
+     *
+     * Pearson hash is named for it's inventor Peter K. Pearson who described
+     * it in his article "Fast hashing of variable-length text strings"
+     * published in 1990 by ACM.  I haven't read it, because you have to pay to
+     * get a copy :-P
+     */
+    class PearsonHash : public Bu::CryptoHash
+    {
+    public:
+        PearsonHash();
+        virtual ~PearsonHash();
 
-                virtual void reset();
-                virtual void setSalt( const Bu::String &sSalt );
-                virtual void addData( const void *sData, int iSize );
-                using Bu::CryptoHash::addData;
-                virtual String getResult();
-                virtual void writeResult( Stream &sOut );
+        virtual void reset();
+        virtual void setSalt( const Bu::String &sSalt );
+        virtual void addData( const void *sData, int iSize );
+        using Bu::CryptoHash::addData;
+        virtual String getResult();
+        virtual void writeResult( Stream &sOut );
 
-        private:
-                static uint8_t aSBox[256];
-                uint8_t iValue;
-        };
+    private:
+        static uint8_t aSBox[256];
+        uint8_t iValue;
+    };
 };
 
 #endif
diff --git a/src/stable/plugger.h b/src/stable/plugger.h
index d9eaf34..424613f 100644
--- a/src/stable/plugger.h
+++ b/src/stable/plugger.h
@@ -24,59 +24,59 @@
 
 namespace Bu
 {
-        subExceptionDecl( PluginException );
+    subExceptionDecl( PluginException );
 
-        typedef struct PluginInfo
-        {
-                const char *sID;
-                const char *sAuthor;
-                unsigned short nVersion;
-                unsigned short nRevision;
-                void *(*createPlugin)();
-                void (*destroyPlugin)( void * );
-        } PluginInfo;
+    typedef struct PluginInfo
+    {
+        const char *sID;
+        const char *sAuthor;
+        unsigned short nVersion;
+        unsigned short nRevision;
+        void *(*createPlugin)();
+        void (*destroyPlugin)( void * );
+    } PluginInfo;
 
-        typedef struct PluginReg
-        {
-                bool bBuiltin;
+    typedef struct PluginReg
+    {
+        bool bBuiltin;
 #ifdef WIN32
-                HMODULE dlHandle;
+        HMODULE dlHandle;
 #else
-                void *dlHandle;
+        void *dlHandle;
 #endif
-                PluginInfo *pInfo;
-        } PluginReg;
+        PluginInfo *pInfo;
+    } PluginReg;
 
-#define PluginInterface( classname, baseclass, name, ver, rev )                 \
-        extern "C" {                                                                                                                    \
-                baseclass *create ##classname()                                                         \
-                {                                                                                                                                       \
-                        return new classname();                                                                                 \
-                }                                                                                                                                       \
-                void destroy ##classname( baseclass *pCls )                                     \
-                {                                                                                                                                       \
-                        delete pCls;                                                                                                    \
-                }                                                                                                                                       \
-                Bu::PluginInfo classname = {                                            \
-                        #classname, name, ver, rev,                                                                             \
-                        create ##classname, destroy ##classname };                                              \
-        }
+#define PluginInterface( classname, baseclass, name, ver, rev )         \
+    extern "C" {                                                            \
+        baseclass *create ##classname()                             \
+        {                                                                   \
+            return new classname();                                         \
+        }                                                                   \
+        void destroy ##classname( baseclass *pCls )                 \
+        {                                                                   \
+            delete pCls;                                                    \
+        }                                                                   \
+        Bu::PluginInfo classname = {                        \
+            #classname, name, ver, rev,                                     \
+            create ##classname, destroy ##classname };                      \
+    }
 
 #define PluginInterface2( pluginname, classname, baseclass, name, ver, rev ) \
-        extern "C" {                                                                                                                    \
-                baseclass *create ##classname()                                                                         \
-                {                                                                                                                                       \
-                        return new classname();                                                                                 \
-                }                                                                                                                                       \
-                void destroy ##classname( baseclass *pCls )                                                     \
-                {                                                                                                                                       \
-                        delete pCls;                                                                                                    \
-                }                                                                                                                                       \
-                Bu::PluginInfo pluginname = {                                                                                   \
-                        #pluginname, name, ver, rev,                                                                    \
-                        (void *(*)())(create ##classname),                                                              \
-                        (void (*)( void * ))(destroy ##classname) };                                    \
-        }
+    extern "C" {                                                            \
+        baseclass *create ##classname()                                     \
+        {                                                                   \
+            return new classname();                                         \
+        }                                                                   \
+        void destroy ##classname( baseclass *pCls )                         \
+        {                                                                   \
+            delete pCls;                                                    \
+        }                                                                   \
+        Bu::PluginInfo pluginname = {                                           \
+            #pluginname, name, ver, rev,                                    \
+            (void *(*)())(create ##classname),                              \
+            (void (*)( void * ))(destroy ##classname) };                    \
+    }
 
 //
 // This is probably the main interface to use, I'll describe it some here...
@@ -93,197 +93,197 @@ namespace Bu
 //   rev        - an integer revision number for the plugin
 //
 #define PluginInterface3( structname, pluginname, classname, baseclass, name, ver, rev ) \
-        extern "C" {                                                                                                                    \
-                baseclass *create ##classname()                                                                         \
-                {                                                                                                                                       \
-                        return new classname();                                                                                 \
-                }                                                                                                                                       \
-                void destroy ##classname( baseclass *pCls )                                                     \
-                {                                                                                                                                       \
-                        delete pCls;                                                                                                    \
-                }                                                                                                                                       \
-                Bu::PluginInfo structname = {                                                                                   \
-                        #pluginname, name, ver, rev,                                                                    \
-                        (void *(*)())(create ##classname),                                                              \
-                        (void (*)( void * ))(destroy ##classname) };                                    \
-        }
+    extern "C" {                                                            \
+        baseclass *create ##classname()                                     \
+        {                                                                   \
+            return new classname();                                         \
+        }                                                                   \
+        void destroy ##classname( baseclass *pCls )                         \
+        {                                                                   \
+            delete pCls;                                                    \
+        }                                                                   \
+        Bu::PluginInfo structname = {                                           \
+            #pluginname, name, ver, rev,                                    \
+            (void *(*)())(create ##classname),                              \
+            (void (*)( void * ))(destroy ##classname) };                    \
+    }
 
-        /**
-         * A complete dynamic plugin manager system.  This will allow you to design
-         * and use plugins that are compiled into your program and dynamically
-         * linked to your program interchangably.  It works on windows and on *nix
-         * and bsd type systems (anything that supports dlopen).  Basically you
-         * create a base class that will be the basic interface of your plugins.
-         * Then you create some classes that inherit from it, and use the
-         * PluginInterface3 macro to create the required data structures for it.
-         *
-         * Once you have plugins you can create a Plugger, by passing in the base
-         * class as it's template parameter.  Once it's created, you can register
-         * plugins.  To register a plugin that is builtin, you just need to pass
-         * a pointer to it's interface structure to the registerBuiltinPlugin
-         * function.  To register a plugin that is in a shared object or dll file
-         * you just pass the filename (with path, probably), and the name of the
-         * structure to load and you're all set.
-         *
-         * To instantiate an object from a plugin simply call instantiate with the
-         * name of the plugin as specified in the interface macro.  To destroy an
-         * object crated with the plugger do not delete it, instead pass it into
-         * Plugger's destroy function.
-         *
-         * Any objects not destroyed when the plugger is deleted will be destroyed
-         * automatically.
-         *
-         * It is important to note that some systems (linux at least) partition off
-         * the memory allocated by objects linked in at run time into a seperate
-         * segment that, while it can be accessed by the main program, cannot be
-         * safely or reliably freed by the main program.  With that in mind it is
-         * a good idea to free all memory allocated by a plugin object in the plugin
-         * object and not allow the calling program to delete it.
-         */
-        template<class T>
-        class Plugger
-        {
-        public:
-                typedef Bu::Hash<Bu::String, PluginReg *> PluginHash;
-                typedef Bu::Hash<ptrdiff_t, void *> InstHash;
+    /**
+     * A complete dynamic plugin manager system.  This will allow you to design
+     * and use plugins that are compiled into your program and dynamically
+     * linked to your program interchangably.  It works on windows and on *nix
+     * and bsd type systems (anything that supports dlopen).  Basically you
+     * create a base class that will be the basic interface of your plugins.
+     * Then you create some classes that inherit from it, and use the
+     * PluginInterface3 macro to create the required data structures for it.
+     *
+     * Once you have plugins you can create a Plugger, by passing in the base
+     * class as it's template parameter.  Once it's created, you can register
+     * plugins.  To register a plugin that is builtin, you just need to pass
+     * a pointer to it's interface structure to the registerBuiltinPlugin
+     * function.  To register a plugin that is in a shared object or dll file
+     * you just pass the filename (with path, probably), and the name of the
+     * structure to load and you're all set.
+     *
+     * To instantiate an object from a plugin simply call instantiate with the
+     * name of the plugin as specified in the interface macro.  To destroy an
+     * object crated with the plugger do not delete it, instead pass it into
+     * Plugger's destroy function.
+     *
+     * Any objects not destroyed when the plugger is deleted will be destroyed
+     * automatically.
+     *
+     * It is important to note that some systems (linux at least) partition off
+     * the memory allocated by objects linked in at run time into a seperate
+     * segment that, while it can be accessed by the main program, cannot be
+     * safely or reliably freed by the main program.  With that in mind it is
+     * a good idea to free all memory allocated by a plugin object in the plugin
+     * object and not allow the calling program to delete it.
+     */
+    template<class T>
+    class Plugger
+    {
+    public:
+        typedef Bu::Hash<Bu::String, PluginReg *> PluginHash;
+        typedef Bu::Hash<ptrdiff_t, void *> InstHash;
 
-        public:
-                Plugger()
-                {
-                }
+    public:
+        Plugger()
+        {
+        }
 
-                virtual ~Plugger()
-                {
-                        for( InstHash::iterator i = hObj.begin(); i != hObj.end(); i++ )
-                        {
-                                T *pPlug = (T *)i.getKey();
-                                PluginReg *pReg = (PluginReg *)*i;
-                                pReg->pInfo->destroyPlugin( pPlug );
-                        }
+        virtual ~Plugger()
+        {
+            for( InstHash::iterator i = hObj.begin(); i != hObj.end(); i++ )
+            {
+                T *pPlug = (T *)i.getKey();
+                PluginReg *pReg = (PluginReg *)*i;
+                pReg->pInfo->destroyPlugin( pPlug );
+            }
 
-                        for( PluginHash::iterator i = hPlugin.begin();
-                                 i != hPlugin.end(); i++ )
-                        {
-                                if( (*i)->bBuiltin == false )
-                                {
+            for( PluginHash::iterator i = hPlugin.begin();
+                 i != hPlugin.end(); i++ )
+            {
+                if( (*i)->bBuiltin == false )
+                {
 #ifdef WIN32
-                                        FreeLibrary( (*i)->dlHandle );
+                    FreeLibrary( (*i)->dlHandle );
 #else
-                                        dlclose( (*i)->dlHandle );
+                    dlclose( (*i)->dlHandle );
 #endif
-                                }
-                                delete (*i);
-                        }
-                }
+                }
+                delete (*i);
+            }
+        }
 
-                void registerBuiltinPlugin( PluginInfo *pInfo )
-                {
-                        PluginReg *pReg = new PluginReg;
-                        pReg->bBuiltin = true;
-                        pReg->pInfo = pInfo;
-                        hPlugin.insert( pInfo->sID, pReg );
-                }
+        void registerBuiltinPlugin( PluginInfo *pInfo )
+        {
+            PluginReg *pReg = new PluginReg;
+            pReg->bBuiltin = true;
+            pReg->pInfo = pInfo;
+            hPlugin.insert( pInfo->sID, pReg );
+        }
 
-                void registerExternalPlugin( const Bu::String &sFName,
-                                const Bu::String &sPluginName )
-                {
-                        PluginReg *pReg;
-                        if( hPlugin.has( sPluginName ) )
-                                throw Bu::ExceptionBase("A plugin with name '%s' is already "
-                                        "loaded.", sPluginName.getStr() );
+        void registerExternalPlugin( const Bu::String &sFName,
+                const Bu::String &sPluginName )
+        {
+            PluginReg *pReg;
+            if( hPlugin.has( sPluginName ) )
+                throw Bu::ExceptionBase("A plugin with name '%s' is already "
+                    "loaded.", sPluginName.getStr() );
 
-                        pReg = new PluginReg;
+            pReg = new PluginReg;
 
-                        pReg->bBuiltin = false;
+            pReg->bBuiltin = false;
 #ifdef WIN32
-                        pReg->dlHandle = LoadLibrary( sFName.getStr() );
-                        if( pReg->dlHandle == NULL )
-                        {
-                                throw PluginException( 1, "Error opening %s: %s",
-                                        sFName.getStr(), Bu::getLastWinError().getStr() );
-                        }
-                        pReg->pInfo = (PluginInfo *)GetProcAddress( pReg->dlHandle,
-                                        sPluginName.getStr() );
-                        if( pReg->pInfo == NULL )
-                        {
-                                throw PluginException( 2, "Error mapping %s: %s",
-                                        sFName.getStr(), Bu::getLastWinError().getStr() );
-                        }
+            pReg->dlHandle = LoadLibrary( sFName.getStr() );
+            if( pReg->dlHandle == NULL )
+            {
+                throw PluginException( 1, "Error opening %s: %s",
+                    sFName.getStr(), Bu::getLastWinError().getStr() );
+            }
+            pReg->pInfo = (PluginInfo *)GetProcAddress( pReg->dlHandle,
+                    sPluginName.getStr() );
+            if( pReg->pInfo == NULL )
+            {
+                throw PluginException( 2, "Error mapping %s: %s",
+                    sFName.getStr(), Bu::getLastWinError().getStr() );
+            }
 #else
-                        pReg->dlHandle = dlopen( sFName.getStr(), RTLD_NOW );
-                        if( pReg->dlHandle == NULL )
-                        {
-                                throw PluginException( 1, "Error opening %s: %s",
-                                        sFName.getStr(), dlerror() );
-                        }
-                        pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle,
-                                        sPluginName.getStr() );
-                        if( pReg->pInfo == NULL )
-                        {
-                                throw PluginException( 2, "Error mapping %s: %s",
-                                        sFName.getStr(), dlerror() );
-                        }
+            pReg->dlHandle = dlopen( sFName.getStr(), RTLD_NOW );
+            if( pReg->dlHandle == NULL )
+            {
+                throw PluginException( 1, "Error opening %s: %s",
+                    sFName.getStr(), dlerror() );
+            }
+            pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle,
+                    sPluginName.getStr() );
+            if( pReg->pInfo == NULL )
+            {
+                throw PluginException( 2, "Error mapping %s: %s",
+                    sFName.getStr(), dlerror() );
+            }
 #endif
-                        hPlugin.insert( pReg->pInfo->sID, pReg );
-                }
+            hPlugin.insert( pReg->pInfo->sID, pReg );
+        }
 
-                T *instantiate( const Bu::String &lpName )
-                {
-                        PluginReg *pReg = (PluginReg *)hPlugin[lpName];
-                        if( pReg == NULL )
-                                return NULL;
+        T *instantiate( const Bu::String &lpName )
+        {
+            PluginReg *pReg = (PluginReg *)hPlugin[lpName];
+            if( pReg == NULL )
+                return NULL;
 
-                        T *p = (T *)pReg->pInfo->createPlugin();
-                        hObj.insert( (ptrdiff_t)p, pReg );
-                        //printf("pReg:  %08X, pPlug: %08X\n", pReg, p );
-                
-                        return p;
-                }
+            T *p = (T *)pReg->pInfo->createPlugin();
+            hObj.insert( (ptrdiff_t)p, pReg );
+            //printf("pReg:  %08X, pPlug: %08X\n", pReg, p );
+        
+            return p;
+        }
 
-                bool hasPlugin( const Bu::String &lpName )
-                {
-                        return hPlugin.has( lpName );
-                }
+        bool hasPlugin( const Bu::String &lpName )
+        {
+            return hPlugin.has( lpName );
+        }
 
-                void destroy( T *pPlug )
-                {
-                        PluginReg *pReg = (PluginReg *)hObj.get((ptrdiff_t)pPlug);
-                        //printf("pReg:  %08X, pPlug: %08X\n", pReg, pPlug );
-                        if( pReg == NULL )
-                                return;
+        void destroy( T *pPlug )
+        {
+            PluginReg *pReg = (PluginReg *)hObj.get((ptrdiff_t)pPlug);
+            //printf("pReg:  %08X, pPlug: %08X\n", pReg, pPlug );
+            if( pReg == NULL )
+                return;
 
-                        pReg->pInfo->destroyPlugin( pPlug );
+            pReg->pInfo->destroyPlugin( pPlug );
 
-                        hObj.erase( (ptrdiff_t)pPlug );
-                }
+            hObj.erase( (ptrdiff_t)pPlug );
+        }
 
-                void unloadAll()
-                {
-                        for( PluginHash::iterator i = hPlugin.begin();
-                                 i != hPlugin.end(); i++ )
-                        {
-                                if( (*i)->bBuiltin == false )
-                                {
+        void unloadAll()
+        {
+            for( PluginHash::iterator i = hPlugin.begin();
+                 i != hPlugin.end(); i++ )
+            {
+                if( (*i)->bBuiltin == false )
+                {
 #ifdef WIN32
-                                        FreeLibrary( (*i)->dlHandle );
+                    FreeLibrary( (*i)->dlHandle );
 #else
-                                        dlclose( (*i)->dlHandle );
+                    dlclose( (*i)->dlHandle );
 #endif
-                                }
-                                delete (*i);
-                        }
-                        hPlugin.clear();
-                }
+                }
+                delete (*i);
+            }
+            hPlugin.clear();
+        }
 
-                Bu::List<Bu::String> getPluginList()
-                {
-                        return hPlugin.getKeys();
-                }
+        Bu::List<Bu::String> getPluginList()
+        {
+            return hPlugin.getKeys();
+        }
 
-        private:
-                PluginHash hPlugin;
-                InstHash hObj;
-        };
+    private:
+        PluginHash hPlugin;
+        InstHash hObj;
+    };
 }
 
 #endif
diff --git a/src/stable/process.cpp b/src/stable/process.cpp
index a1adb23..a88ee7c 100644
--- a/src/stable/process.cpp
+++ b/src/stable/process.cpp
@@ -27,422 +27,422 @@
 
 Bu::Process::ProcData::ProcData() :
 #ifdef WIN32
-        hStdIn( NULL ),
-        hStdOut( NULL ),
-        hStdErr( NULL )
+    hStdIn( NULL ),
+    hStdOut( NULL ),
+    hStdErr( NULL )
 #else
-        iStdIn( -1 ),
-        iStdOut( -1 ),
-        iStdErr( -1 )
+    iStdIn( -1 ),
+    iStdOut( -1 ),
+    iStdErr( -1 )
 #endif
 {
 }
 
 
 Bu::Process::Process( Flags eFlags, const char *sName, char *const argv[] ) :
-        iProcStatus( 0 ),
-        bBlocking( true ),
-        bStdOutEos( true ),
-        bStdErrEos( true )
+    iProcStatus( 0 ),
+    bBlocking( true ),
+    bStdOutEos( true ),
+    bStdErrEos( true )
 {
-        gexec( eFlags, sName, argv );
+    gexec( eFlags, sName, argv );
 }
 
 Bu::Process::Process( Flags eFlags, const char *sName, const char *argv, ...) :
-        iProcStatus( 0 ),
-        bBlocking( true ),
-        bStdOutEos( true ),
-        bStdErrEos( true )
-{
-        int iCnt = 0;
-        va_list ap;
-        va_start( ap, argv );
-        for(; va_arg( ap, const char *); iCnt++ ) { }
-        va_end( ap );
-
-        char const **list = new char const *[iCnt+2];
-        va_start( ap, argv );
-        list[0] = argv;
-        for( int j = 1; j <= iCnt; j++ )
-        {
-                list[j] = va_arg( ap, const char *);
-        }
-        list[iCnt+1] = NULL;
-        va_end( ap );
-
-        gexec( eFlags, sName, (char *const *)list );
-        delete[] list;
+    iProcStatus( 0 ),
+    bBlocking( true ),
+    bStdOutEos( true ),
+    bStdErrEos( true )
+{
+    int iCnt = 0;
+    va_list ap;
+    va_start( ap, argv );
+    for(; va_arg( ap, const char *); iCnt++ ) { }
+    va_end( ap );
+
+    char const **list = new char const *[iCnt+2];
+    va_start( ap, argv );
+    list[0] = argv;
+    for( int j = 1; j <= iCnt; j++ )
+    {
+        list[j] = va_arg( ap, const char *);
+    }
+    list[iCnt+1] = NULL;
+    va_end( ap );
+
+    gexec( eFlags, sName, (char *const *)list );
+    delete[] list;
 }
 
 Bu::Process::Process( Flags eFlags, const Bu::Process::Options &opt, const char *sName, char *const argv[] ) :
-        iProcStatus( 0 ),
-        bBlocking( true ),
-        bStdOutEos( true ),
-        bStdErrEos( true ),
-        opt( opt )
+    iProcStatus( 0 ),
+    bBlocking( true ),
+    bStdOutEos( true ),
+    bStdErrEos( true ),
+    opt( opt )
 {
-        gexec( eFlags, sName, argv );
+    gexec( eFlags, sName, argv );
 }
 
 Bu::Process::Process( Flags eFlags, const Bu::Process::Options &opt, const char *sName, const char *argv, ...) :
-        iProcStatus( 0 ),
-        bBlocking( true ),
-        bStdOutEos( true ),
-        bStdErrEos( true ),
-        opt( opt )
-{
-        int iCnt = 0;
-        va_list ap;
-        va_start( ap, argv );
-        for(; va_arg( ap, const char *); iCnt++ ) { }
-        va_end( ap );
-
-        char const **list = new char const *[iCnt+2];
-        va_start( ap, argv );
-        list[0] = argv;
-        for( int j = 1; j <= iCnt; j++ )
-        {
-                list[j] = va_arg( ap, const char *);
-        }
-        list[iCnt+1] = NULL;
-        va_end( ap );
-
-        gexec( eFlags, sName, (char *const *)list );
-        delete[] list;
+    iProcStatus( 0 ),
+    bBlocking( true ),
+    bStdOutEos( true ),
+    bStdErrEos( true ),
+    opt( opt )
+{
+    int iCnt = 0;
+    va_list ap;
+    va_start( ap, argv );
+    for(; va_arg( ap, const char *); iCnt++ ) { }
+    va_end( ap );
+
+    char const **list = new char const *[iCnt+2];
+    va_start( ap, argv );
+    list[0] = argv;
+    for( int j = 1; j <= iCnt; j++ )
+    {
+        list[j] = va_arg( ap, const char *);
+    }
+    list[iCnt+1] = NULL;
+    va_end( ap );
+
+    gexec( eFlags, sName, (char *const *)list );
+    delete[] list;
 }
 
 Bu::Process::~Process()
 {
-        close();
+    close();
 }
 
 void Bu::Process::wait()
 {
-        close();
+    close();
 }
 
 void Bu::Process::gexec( Flags eFlags, const char *sName, char *const argv[] )
 {
 #ifdef WIN32
-        bStdErrEos = true;
-        SECURITY_ATTRIBUTES saAttr;
-        HANDLE hChildStd_IN_Rd;
-        HANDLE hChildStd_IN_Wr;
-        HANDLE hChildStd_OUT_Rd;
-        HANDLE hChildStd_OUT_Wr;
-        PROCESS_INFORMATION piProcInfo;
-
-        saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
-        saAttr.bInheritHandle = TRUE;
-        saAttr.lpSecurityDescriptor = NULL;
-
-        // Create a pipe for the child process's STDOUT. 
-        if ( ! CreatePipe(
-                                &hChildStd_OUT_Rd,
-                                &hChildStd_OUT_Wr,
-                                &saAttr, 0) ) 
-                throw "StdoutRd CreatePipe"; 
-
-        // Ensure the read handle to the pipe for STDOUT is not inherited.
-        if ( ! SetHandleInformation(
-                                hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0) )
-                throw "Stdout SetHandleInformation"; 
-
-        // Create a pipe for the child process's STDIN. 
-        if (! CreatePipe(
-                                &hChildStd_IN_Rd,
-                                &hChildStd_IN_Wr,
-                                &saAttr, 0)) 
-                throw "Stdin CreatePipe"; 
-
-        // Ensure the write handle to the pipe for STDIN is not inherited. 
-        if ( ! SetHandleInformation(
-                                hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) )
-                throw "Stdin SetHandleInformation"; 
-
-        //TCHAR szCmdline[] = TEXT( sName );
-        //PROCESS_INFORMATION pd.piProcInfo; 
-        STARTUPINFO siStartInfo;
-        BOOL bSuccess = FALSE; 
-
-        // Set up members of the PROCESS_INFORMATION structure. 
-        ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
-
-        // Set up members of the STARTUPINFO structure. 
-        // This structure specifies the STDIN and STDOUT handles for redirection.
-        ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
-        siStartInfo.cb = sizeof(STARTUPINFO); 
-        siStartInfo.hStdError = hChildStd_OUT_Wr;
-        siStartInfo.hStdOutput = hChildStd_OUT_Wr;
-        siStartInfo.hStdInput = hChildStd_IN_Rd;
-        siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
-
-        Bu::String sCmd;
-        for( char *const *arg = argv; *arg; arg++ )
-        {
-                if( arg != argv )
-                        sCmd += " ";
-                sCmd += *arg;
-        }
-
-        // Create the child process. 
-        bSuccess = CreateProcessA(
-                sName, //sName,                         //module name
-                sCmd.getStr(), //(TCHAR *) sName, //szCmdline,     // command line 
-                NULL,          // process security attributes 
-                NULL,          // primary thread security attributes 
-                TRUE,          // handles are inherited 
-                CREATE_NO_WINDOW,             // creation flags 
-                NULL,          // use parent's environment 
-                NULL,          // use parent's current directory 
-                &siStartInfo,  // STARTUPINFO pointer 
-                &piProcInfo );  // receives PROCESS_INFORMATION 
-
-        // If an error occurs, exit the application. 
-        if ( ! bSuccess ) 
-        {
-                throw Bu::ExceptionBase("Error spawning child process.");
-                return;
-        }
-        else 
-        {
-                // Close handles to the child process and its primary thread.
-                // Some applications might keep these handles to monitor the status
-                // of the child process, for example. 
-                
-                //CloseHandle(pData->pd.piProcInfo.hProcess);
-                CloseHandle(piProcInfo.hThread);
-                pd.hProcess = piProcInfo.hProcess;
-
-                // Close the ends we can't use
-                CloseHandle( hChildStd_OUT_Wr );
-                CloseHandle( hChildStd_IN_Rd );
-                pd.hStdIn = hChildStd_IN_Wr;
-                pd.hStdOut = hChildStd_OUT_Rd;
-        }
+    bStdErrEos = true;
+    SECURITY_ATTRIBUTES saAttr;
+    HANDLE hChildStd_IN_Rd;
+    HANDLE hChildStd_IN_Wr;
+    HANDLE hChildStd_OUT_Rd;
+    HANDLE hChildStd_OUT_Wr;
+    PROCESS_INFORMATION piProcInfo;
+
+    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
+    saAttr.bInheritHandle = TRUE;
+    saAttr.lpSecurityDescriptor = NULL;
+
+    // Create a pipe for the child process's STDOUT. 
+    if ( ! CreatePipe(
+                &hChildStd_OUT_Rd,
+                &hChildStd_OUT_Wr,
+                &saAttr, 0) ) 
+        throw "StdoutRd CreatePipe"; 
+
+    // Ensure the read handle to the pipe for STDOUT is not inherited.
+    if ( ! SetHandleInformation(
+                hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0) )
+        throw "Stdout SetHandleInformation"; 
+
+    // Create a pipe for the child process's STDIN. 
+    if (! CreatePipe(
+                &hChildStd_IN_Rd,
+                &hChildStd_IN_Wr,
+                &saAttr, 0)) 
+        throw "Stdin CreatePipe"; 
+
+    // Ensure the write handle to the pipe for STDIN is not inherited. 
+    if ( ! SetHandleInformation(
+                hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) )
+        throw "Stdin SetHandleInformation"; 
+
+    //TCHAR szCmdline[] = TEXT( sName );
+    //PROCESS_INFORMATION pd.piProcInfo; 
+    STARTUPINFO siStartInfo;
+    BOOL bSuccess = FALSE; 
+
+    // Set up members of the PROCESS_INFORMATION structure. 
+    ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
+
+    // Set up members of the STARTUPINFO structure. 
+    // This structure specifies the STDIN and STDOUT handles for redirection.
+    ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
+    siStartInfo.cb = sizeof(STARTUPINFO); 
+    siStartInfo.hStdError = hChildStd_OUT_Wr;
+    siStartInfo.hStdOutput = hChildStd_OUT_Wr;
+    siStartInfo.hStdInput = hChildStd_IN_Rd;
+    siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
+
+    Bu::String sCmd;
+    for( char *const *arg = argv; *arg; arg++ )
+    {
+        if( arg != argv )
+            sCmd += " ";
+        sCmd += *arg;
+    }
+
+    // Create the child process. 
+    bSuccess = CreateProcessA(
+        sName, //sName,             //module name
+        sCmd.getStr(), //(TCHAR *) sName, //szCmdline,     // command line 
+        NULL,          // process security attributes 
+        NULL,          // primary thread security attributes 
+        TRUE,          // handles are inherited 
+        CREATE_NO_WINDOW,             // creation flags 
+        NULL,          // use parent's environment 
+        NULL,          // use parent's current directory 
+        &siStartInfo,  // STARTUPINFO pointer 
+        &piProcInfo );  // receives PROCESS_INFORMATION 
+
+    // If an error occurs, exit the application. 
+    if ( ! bSuccess ) 
+    {
+        throw Bu::ExceptionBase("Error spawning child process.");
+        return;
+    }
+    else 
+    {
+        // Close handles to the child process and its primary thread.
+        // Some applications might keep these handles to monitor the status
+        // of the child process, for example. 
+        
+        //CloseHandle(pData->pd.piProcInfo.hProcess);
+        CloseHandle(piProcInfo.hThread);
+        pd.hProcess = piProcInfo.hProcess;
+
+        // Close the ends we can't use
+        CloseHandle( hChildStd_OUT_Wr );
+        CloseHandle( hChildStd_IN_Rd );
+        pd.hStdIn = hChildStd_IN_Wr;
+        pd.hStdOut = hChildStd_OUT_Rd;
+    }
 #else
-        int iaStdIn[2];
-        int iaStdOut[2];
-        int iaStdErr[2];
-        pipe( iaStdIn );
-        if( eFlags & StdOut )
-        {
-                pipe( iaStdOut );
-                pd.iStdOut = iaStdOut[0];
-                bStdOutEos = false;
-        }
-        if( eFlags & StdErr )
-        {
-                pipe( iaStdErr );
-                pd.iStdErr = iaStdErr[0];
-                bStdErrEos = false;
-        }
-
-        pd.iStdIn = iaStdIn[1];
-
-//      fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK );
-
-        pd.iPid = fork();
-        if( pd.iPid == 0 )
-        {
-                ::close( iaStdIn[1] );
-                dup2( iaStdIn[0], 0 );
-                if( eFlags & StdOut )
-                {
-                        ::close( iaStdOut[0] );
-                        dup2( iaStdOut[1], 1 );
-                }
-                if( eFlags & StdErr )
-                {
-                        ::close( iaStdErr[0] );
-                        dup2( iaStdErr[1], 2 );
-                }
-                if( (opt.eFlags&Options::SetGid) )
-                {
-                        setgid( opt.iGid );
-                }
-                if( (opt.eFlags&Options::SetUid) )
-                {
-                        setuid( opt.iUid );
-                }
-                execvp( sName, argv );
-                throw Bu::ExceptionBase("Hey, execvp failed!");
-        }
-        ::close( iaStdIn[0] );
-        if( eFlags & StdOut )
-                ::close( iaStdOut[1] );
-        if( eFlags & StdErr )
-                ::close( iaStdErr[1] );
+    int iaStdIn[2];
+    int iaStdOut[2];
+    int iaStdErr[2];
+    pipe( iaStdIn );
+    if( eFlags & StdOut )
+    {
+        pipe( iaStdOut );
+        pd.iStdOut = iaStdOut[0];
+        bStdOutEos = false;
+    }
+    if( eFlags & StdErr )
+    {
+        pipe( iaStdErr );
+        pd.iStdErr = iaStdErr[0];
+        bStdErrEos = false;
+    }
+
+    pd.iStdIn = iaStdIn[1];
+
+//  fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK );
+
+    pd.iPid = fork();
+    if( pd.iPid == 0 )
+    {
+        ::close( iaStdIn[1] );
+        dup2( iaStdIn[0], 0 );
+        if( eFlags & StdOut )
+        {
+            ::close( iaStdOut[0] );
+            dup2( iaStdOut[1], 1 );
+        }
+        if( eFlags & StdErr )
+        {
+            ::close( iaStdErr[0] );
+            dup2( iaStdErr[1], 2 );
+        }
+        if( (opt.eFlags&Options::SetGid) )
+        {
+            setgid( opt.iGid );
+        }
+        if( (opt.eFlags&Options::SetUid) )
+        {
+            setuid( opt.iUid );
+        }
+        execvp( sName, argv );
+        throw Bu::ExceptionBase("Hey, execvp failed!");
+    }
+    ::close( iaStdIn[0] );
+    if( eFlags & StdOut )
+        ::close( iaStdOut[1] );
+    if( eFlags & StdErr )
+        ::close( iaStdErr[1] );
 #endif
 }
 
 void Bu::Process::close()
 {
 #ifdef WIN32
-        if( pd.hStdIn )
-        {
-                CloseHandle( pd.hStdIn );
-                CloseHandle( pd.hStdOut );
-
-                pd.hStdIn = pd.hStdOut = pd.hStdErr = NULL;
-
-                if( !TerminateProcess(pd.hProcess, 1) )
-                {
-                        throw Bu::ExceptionBase("Error closing process.");
-                }
-                
-                GetExitCodeProcess( pd.hProcess, (PDWORD)&iProcStatus );
-
-                CloseHandle( pd.hProcess );
-                pd.hProcess = NULL;
-        }
+    if( pd.hStdIn )
+    {
+        CloseHandle( pd.hStdIn );
+        CloseHandle( pd.hStdOut );
+
+        pd.hStdIn = pd.hStdOut = pd.hStdErr = NULL;
+
+        if( !TerminateProcess(pd.hProcess, 1) )
+        {
+            throw Bu::ExceptionBase("Error closing process.");
+        }
+        
+        GetExitCodeProcess( pd.hProcess, (PDWORD)&iProcStatus );
+
+        CloseHandle( pd.hProcess );
+        pd.hProcess = NULL;
+    }
 #else
-        if( pd.iPid )
-        {
-                if( pd.iStdIn > -1 )
-                        ::close( pd.iStdIn );
-                if( pd.iStdOut > -1 )
-                        ::close( pd.iStdOut );
-                if( pd.iStdErr > -1 )
-                        ::close( pd.iStdErr );
-                waitpid( pd.iPid, &iProcStatus, 0 );
-                pd.iPid = 0;
-        }
+    if( pd.iPid )
+    {
+        if( pd.iStdIn > -1 )
+            ::close( pd.iStdIn );
+        if( pd.iStdOut > -1 )
+            ::close( pd.iStdOut );
+        if( pd.iStdErr > -1 )
+            ::close( pd.iStdErr );
+        waitpid( pd.iPid, &iProcStatus, 0 );
+        pd.iPid = 0;
+    }
 #endif
 }
 
 void Bu::Process::closeStdIn()
 {
 #ifdef WIN32
-        CloseHandle( pd.hStdIn );
-        pd.hStdIn = NULL;
+    CloseHandle( pd.hStdIn );
+    pd.hStdIn = NULL;
 #else
-        ::close( pd.iStdIn );
-        pd.iStdIn = -1;
+    ::close( pd.iStdIn );
+    pd.iStdIn = -1;
 #endif
 }
 
 void Bu::Process::closeStdOut()
 {
 #ifdef WIN32
-        CloseHandle( pd.hStdOut );
-        pd.hStdOut = NULL;
+    CloseHandle( pd.hStdOut );
+    pd.hStdOut = NULL;
 #else
-        ::close( pd.iStdOut );
-        pd.iStdOut = -1;
+    ::close( pd.iStdOut );
+    pd.iStdOut = -1;
 #endif
 }
 
 Bu::size Bu::Process::read( void *pBuf, Bu::size nBytes )
 {
 #ifdef WIN32
-        DWORD dwRead;
-        DWORD lExitCode;
-        BOOL bSuccess = FALSE;
-        DWORD dwLen = (DWORD) nBytes;
-        bSuccess = ReadFile(
-                        pd.hStdOut, (char *) pBuf,
-                        dwLen, &dwRead, NULL);
-//      if( dwRead < dwLen )
-        {
-                bSuccess = GetExitCodeProcess( pd.hProcess, &lExitCode );
-                if( lExitCode != STILL_ACTIVE )
-                {
-                        bStdOutEos = true;
-                }
-        }
-        return (int32_t) dwRead;
+    DWORD dwRead;
+    DWORD lExitCode;
+    BOOL bSuccess = FALSE;
+    DWORD dwLen = (DWORD) nBytes;
+    bSuccess = ReadFile(
+            pd.hStdOut, (char *) pBuf,
+            dwLen, &dwRead, NULL);
+//  if( dwRead < dwLen )
+    {
+        bSuccess = GetExitCodeProcess( pd.hProcess, &lExitCode );
+        if( lExitCode != STILL_ACTIVE )
+        {
+            bStdOutEos = true;
+        }
+    }
+    return (int32_t) dwRead;
 #else
-        if( bStdOutEos )
-                return 0;
-        fd_set rfds;
-        FD_ZERO( &rfds );
-        FD_SET( pd.iStdOut, &rfds );
-        struct timeval tv = {0, 0};
-        if( ::bu_select( pd.iStdOut+1, &rfds, NULL, NULL, &tv ) < 0 )
-                throw Bu::ExceptionBase( strerror( errno ) );
-        if( FD_ISSET( pd.iStdOut, &rfds ) || bBlocking )
-        {
-                Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdOut, pBuf, nBytes ) );
-                if( nRead == 0 )
-                {
-                        bStdOutEos = true;
-                        checkClose();
-                        return 0;
-                }
-                if( nRead < 0 )
-                {
-                        if( errno == EAGAIN )
-                                return 0;
-                        throw Bu::ExceptionBase( strerror( errno ) );
-                }
-                return nRead;
-        }
-        return 0;
+    if( bStdOutEos )
+        return 0;
+    fd_set rfds;
+    FD_ZERO( &rfds );
+    FD_SET( pd.iStdOut, &rfds );
+    struct timeval tv = {0, 0};
+    if( ::bu_select( pd.iStdOut+1, &rfds, NULL, NULL, &tv ) < 0 )
+        throw Bu::ExceptionBase( strerror( errno ) );
+    if( FD_ISSET( pd.iStdOut, &rfds ) || bBlocking )
+    {
+        Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdOut, pBuf, nBytes ) );
+        if( nRead == 0 )
+        {
+            bStdOutEos = true;
+            checkClose();
+            return 0;
+        }
+        if( nRead < 0 )
+        {
+            if( errno == EAGAIN )
+                return 0;
+            throw Bu::ExceptionBase( strerror( errno ) );
+        }
+        return nRead;
+    }
+    return 0;
 #endif
 }
 
 Bu::size Bu::Process::readErr( void *pBuf, Bu::size nBytes )
 {
 #ifdef WIN32
-        if( !pd.hStdErr )
-                return 0;
-        DWORD dwRead;
-        BOOL bSuccess = FALSE;
-        DWORD dwLen = (DWORD) nBytes;
-        bSuccess = ReadFile(
-                        pd.hStdErr, (char *) pBuf,
-                        dwLen, &dwRead, NULL);
-        return (int32_t) dwRead;
+    if( !pd.hStdErr )
+        return 0;
+    DWORD dwRead;
+    BOOL bSuccess = FALSE;
+    DWORD dwLen = (DWORD) nBytes;
+    bSuccess = ReadFile(
+            pd.hStdErr, (char *) pBuf,
+            dwLen, &dwRead, NULL);
+    return (int32_t) dwRead;
 #else
-        if( bStdErrEos )
-                return 0;
-        fd_set rfds;
-        FD_ZERO( &rfds );
-        FD_SET( pd.iStdErr, &rfds );
-        struct timeval tv = {0, 0};
-        if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, &tv ) < 0 )
-                throw Bu::ExceptionBase( strerror( errno ) );
-        if( FD_ISSET( pd.iStdErr, &rfds ) || bBlocking )
-        {
-                Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdErr, pBuf, nBytes ) );
-                if( nRead == 0 )
-                {
-                        bStdErrEos = true;
-                        checkClose();
-                        return 0;
-                }
-                if( nRead < 0 )
-                {
-                        if( errno == EAGAIN )
-                                return 0;
-                        throw Bu::ExceptionBase( strerror( errno ) );
-                }
-                return nRead;
-        }
-        return 0;
+    if( bStdErrEos )
+        return 0;
+    fd_set rfds;
+    FD_ZERO( &rfds );
+    FD_SET( pd.iStdErr, &rfds );
+    struct timeval tv = {0, 0};
+    if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, &tv ) < 0 )
+        throw Bu::ExceptionBase( strerror( errno ) );
+    if( FD_ISSET( pd.iStdErr, &rfds ) || bBlocking )
+    {
+        Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdErr, pBuf, nBytes ) );
+        if( nRead == 0 )
+        {
+            bStdErrEos = true;
+            checkClose();
+            return 0;
+        }
+        if( nRead < 0 )
+        {
+            if( errno == EAGAIN )
+                return 0;
+            throw Bu::ExceptionBase( strerror( errno ) );
+        }
+        return nRead;
+    }
+    return 0;
 #endif
 }
 
 Bu::size Bu::Process::write( const void *pBuf, Bu::size nBytes )
 {
 #ifdef WIN32
-        DWORD dwWritten;
-        BOOL bSuccess = FALSE;
-        DWORD dwLen = (DWORD) nBytes;
-        bSuccess = WriteFile( 
-                        pd.hStdIn, (const char *) pBuf,
-                        dwLen, &dwWritten, NULL );
-        FlushFileBuffers( pd.hStdIn );
-        return (int32_t) dwWritten;
+    DWORD dwWritten;
+    BOOL bSuccess = FALSE;
+    DWORD dwLen = (DWORD) nBytes;
+    bSuccess = WriteFile( 
+            pd.hStdIn, (const char *) pBuf,
+            dwLen, &dwWritten, NULL );
+    FlushFileBuffers( pd.hStdIn );
+    return (int32_t) dwWritten;
 #else
-        return TEMP_FAILURE_RETRY( ::write( pd.iStdIn, pBuf, nBytes ) );
+    return TEMP_FAILURE_RETRY( ::write( pd.iStdIn, pBuf, nBytes ) );
 #endif
 }
 
 Bu::size Bu::Process::tell()
 {
-        return 0;
+    return 0;
 }
 
 void Bu::Process::seek( Bu::size )
@@ -460,15 +460,15 @@ void Bu::Process::setPosEnd( Bu::size )
 bool Bu::Process::isEos()
 {
 #ifdef WIN32
-        return (pd.hProcess == NULL);
+    return (pd.hProcess == NULL);
 #else
-        return (pd.iPid == 0);
+    return (pd.iPid == 0);
 #endif
 }
 
 bool Bu::Process::isOpen()
 {
-        return !isEos();
+    return !isEos();
 }
 
 void Bu::Process::flush()
@@ -477,53 +477,53 @@ void Bu::Process::flush()
 
 bool Bu::Process::canRead()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Process::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Process::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Process::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::Process::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::Process::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::Process::setBlocking( bool bBlocking )
 {
 #ifdef WIN32
 #else
-        if( bBlocking )
-        {
-                if( !bStdOutEos )
-                        fcntl( pd.iStdOut, F_SETFL, fcntl(pd.iStdOut,F_GETFL,0 )&(~O_NONBLOCK) );
-                if( !bStdErrEos )
-                        fcntl( pd.iStdErr, F_SETFL, fcntl(pd.iStdErr,F_GETFL,0 )&(~O_NONBLOCK) );
-        }
-        else
-        {
-                if( !bStdOutEos )
-                        fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK );
-                if( !bStdErrEos )
-                        fcntl( pd.iStdErr, F_SETFL, fcntl( pd.iStdErr, F_GETFL, 0 )|O_NONBLOCK );
-        }
-        this->bBlocking = bBlocking;
+    if( bBlocking )
+    {
+        if( !bStdOutEos )
+            fcntl( pd.iStdOut, F_SETFL, fcntl(pd.iStdOut,F_GETFL,0 )&(~O_NONBLOCK) );
+        if( !bStdErrEos )
+            fcntl( pd.iStdErr, F_SETFL, fcntl(pd.iStdErr,F_GETFL,0 )&(~O_NONBLOCK) );
+    }
+    else
+    {
+        if( !bStdOutEos )
+            fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK );
+        if( !bStdErrEos )
+            fcntl( pd.iStdErr, F_SETFL, fcntl( pd.iStdErr, F_GETFL, 0 )|O_NONBLOCK );
+    }
+    this->bBlocking = bBlocking;
 #endif
 }
 
@@ -533,128 +533,128 @@ void Bu::Process::setSize( Bu::size )
 
 Bu::size Bu::Process::getBlockSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::Process::getSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::String Bu::Process::getLocation() const
 {
-        return "";
+    return "";
 }
 
 void Bu::Process::select( bool &bStdOut, bool &bStdErr )
 {
 #ifdef WIN32
 #else
-        fd_set rfds;
-        FD_ZERO( &rfds );
-        if( !bStdOutEos )
-                FD_SET( pd.iStdOut, &rfds );
-        if( !bStdErrEos )
-                FD_SET( pd.iStdErr, &rfds );
-        if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, NULL ) < 0 )  
-                throw Bu::ExceptionBase( strerror( errno ) );
-
-        if( FD_ISSET( pd.iStdOut, &rfds ) )
-                bStdOut = true;
-        else
-                bStdOut = false;
-
-        if( FD_ISSET( pd.iStdErr, &rfds ) )
-                bStdErr = true;
-        else
-                bStdErr = false;
+    fd_set rfds;
+    FD_ZERO( &rfds );
+    if( !bStdOutEos )
+        FD_SET( pd.iStdOut, &rfds );
+    if( !bStdErrEos )
+        FD_SET( pd.iStdErr, &rfds );
+    if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, NULL ) < 0 )  
+        throw Bu::ExceptionBase( strerror( errno ) );
+
+    if( FD_ISSET( pd.iStdOut, &rfds ) )
+        bStdOut = true;
+    else
+        bStdOut = false;
+
+    if( FD_ISSET( pd.iStdErr, &rfds ) )
+        bStdErr = true;
+    else
+        bStdErr = false;
 #endif
 }
 
 bool Bu::Process::isRunning()
 {
 #ifdef WIN32
-        DWORD lExitCode;
-        GetExitCodeProcess( pd.hProcess, &lExitCode );
-        if( lExitCode != STILL_ACTIVE )
-                checkClose();
+    DWORD lExitCode;
+    GetExitCodeProcess( pd.hProcess, &lExitCode );
+    if( lExitCode != STILL_ACTIVE )
+        checkClose();
 #else
-        if( waitpid( pd.iPid, NULL, WNOHANG ) == pd.iPid )
-                checkClose();
+    if( waitpid( pd.iPid, NULL, WNOHANG ) == pd.iPid )
+        checkClose();
 #endif
-        return isOpen();
+    return isOpen();
 }
 
 void Bu::Process::ignoreStdErr()
 {
 #ifdef WIN32
 #else
-        if( pd.iStdErr == -1 )
-                return;
-        ::close( pd.iStdErr );
-        pd.iStdErr = -1;
-        bStdErrEos = true;
+    if( pd.iStdErr == -1 )
+        return;
+    ::close( pd.iStdErr );
+    pd.iStdErr = -1;
+    bStdErrEos = true;
 #endif
 }
 
 pid_t Bu::Process::getPid()
 {
 #ifdef WIN32
-        return 0;
+    return 0;
 #else
-        return pd.iPid;
+    return pd.iPid;
 #endif
 }
 
 bool Bu::Process::childExited()
 {
 #ifdef WIN32
-        return pd.hProcess != NULL;
+    return pd.hProcess != NULL;
 #else
-        return WIFEXITED( iProcStatus );
+    return WIFEXITED( iProcStatus );
 #endif
 }
 
 int Bu::Process::childExitStatus()
 {
 #ifdef WIN32
-        return iProcStatus;
+    return iProcStatus;
 #else
-        return WEXITSTATUS( iProcStatus );
+    return WEXITSTATUS( iProcStatus );
 #endif
 }
 
 bool Bu::Process::childSignaled()
 {
 #ifdef WIN32
-        return false;
+    return false;
 #else
-        return WIFSIGNALED( iProcStatus );
+    return WIFSIGNALED( iProcStatus );
 #endif
 }
 
 int Bu::Process::childSignal()
 {
 #ifdef WIN32
-        return 0;
+    return 0;
 #else
-        return WTERMSIG( iProcStatus );
+    return WTERMSIG( iProcStatus );
 #endif
 }
 
 bool Bu::Process::childCoreDumped()
 {
 #ifdef WIN32
-        return false;
+    return false;
 #else
-        return WCOREDUMP( iProcStatus );
+    return WCOREDUMP( iProcStatus );
 #endif
 }
 
 void Bu::Process::checkClose()
 {
-        if( bStdOutEos && bStdErrEos )
-        {
-                close();
-        }
+    if( bStdOutEos && bStdErrEos )
+    {
+        close();
+    }
 }
diff --git a/src/stable/process.h b/src/stable/process.h
index 904606a..72b686a 100644
--- a/src/stable/process.h
+++ b/src/stable/process.h
@@ -16,151 +16,151 @@
 
 namespace Bu
 {
-        /**
-         * Runs a program and attaches streams to it's stdin, stdout, and stderr.
-         * Reading from a Bu::Process will read from the program's standard output,
-         * writing to a Bu::Process will write to the program's standard input.
-         */
-        class Process : public Bu::Stream
-        {
-        public:
-                enum Flags
-                {
-                        None    =       0x00,
-                        StdOut  =       0x01,
-                        StdErr  =       0x02,
-                        Both    =       0x03
-                };
-
-        public:
-                class Options
-                {
-                public:
-                        enum OptFlags
-                        {
-                                None    = 0x00,
-                                SetUid  = 0x01,
-                                SetGid  = 0x02,
-                        };
-
-                        Options() : eFlags( None ) {}
-
-                        int eFlags;
-                        int iUid;
-                        int iGid;
-                };
-
-                Process( Flags eFlags, const char *sName, char *const argv[] );
-                Process( Flags eFlags, const char *sName, const char *argv, ...);
-                Process( Flags eFlags, const Options &opt, const char *sName, char *const argv[] );
-                Process( Flags eFlags, const Options &opt, const char *sName, const char *argv, ...);
-                virtual ~Process();
-
-                /**
-                 * Waits until the process exits.  This blocks the caller until the
-                 * child process terminates.
-                 */
-                void wait();
-
-                virtual void close();
-                virtual void closeStdIn();
-                virtual void closeStdOut();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size readErr( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
-
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-
-                virtual void flush();
-
-                virtual bool canRead();
-                virtual bool canWrite();
-
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-
-                virtual void setSize( Bu::size iSize );
-
-                virtual size getBlockSize() const;
-                virtual size getSize() const;
-                virtual Bu::String getLocation() const;
-
-                void select( bool &bStdOut, bool &bStdErr );
-
-                bool isRunning();
-                void ignoreStdErr();
-
-                /**
-                 * Returns the pid of the child process, or zero if there is no
-                 * currently running child.  Note that a read operation must be
-                 * performed in order to discover that the child has ended.
-                 */
-                pid_t getPid();
-
-                /**
-                 * Returns true if the child exited normally (by calling exit or
-                 * returning from main).
-                 */
-                bool childExited();
-
-                /**
-                 * Returns the 8 bit integer value returned from the child program if
-                 * childExited returned true.
-                 */
-                int childExitStatus();
-
-                /**
-                 * Returns true if the child exited because of a signal.
-                 */
-                bool childSignaled();
-
-                /**
-                 * Returns the signal ID if the childSignaled return true.
-                 */
-                int childSignal();
-
-                /**
-                 * Returns true if the child left a core dump behind when it exited.
-                 */
-                bool childCoreDumped();
-
-        private:
-                class ProcData
-                {
-                public:
-                        ProcData();
+    /**
+     * Runs a program and attaches streams to it's stdin, stdout, and stderr.
+     * Reading from a Bu::Process will read from the program's standard output,
+     * writing to a Bu::Process will write to the program's standard input.
+     */
+    class Process : public Bu::Stream
+    {
+    public:
+        enum Flags
+        {
+            None    =   0x00,
+            StdOut  =   0x01,
+            StdErr  =   0x02,
+            Both    =   0x03
+        };
+
+    public:
+        class Options
+        {
+        public:
+            enum OptFlags
+            {
+                None    = 0x00,
+                SetUid  = 0x01,
+                SetGid  = 0x02,
+            };
+
+            Options() : eFlags( None ) {}
+
+            int eFlags;
+            int iUid;
+            int iGid;
+        };
+
+        Process( Flags eFlags, const char *sName, char *const argv[] );
+        Process( Flags eFlags, const char *sName, const char *argv, ...);
+        Process( Flags eFlags, const Options &opt, const char *sName, char *const argv[] );
+        Process( Flags eFlags, const Options &opt, const char *sName, const char *argv, ...);
+        virtual ~Process();
+
+        /**
+         * Waits until the process exits.  This blocks the caller until the
+         * child process terminates.
+         */
+        void wait();
+
+        virtual void close();
+        virtual void closeStdIn();
+        virtual void closeStdOut();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size readErr( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
+
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+
+        virtual void flush();
+
+        virtual bool canRead();
+        virtual bool canWrite();
+
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+
+        virtual void setSize( Bu::size iSize );
+
+        virtual size getBlockSize() const;
+        virtual size getSize() const;
+        virtual Bu::String getLocation() const;
+
+        void select( bool &bStdOut, bool &bStdErr );
+
+        bool isRunning();
+        void ignoreStdErr();
+
+        /**
+         * Returns the pid of the child process, or zero if there is no
+         * currently running child.  Note that a read operation must be
+         * performed in order to discover that the child has ended.
+         */
+        pid_t getPid();
+
+        /**
+         * Returns true if the child exited normally (by calling exit or
+         * returning from main).
+         */
+        bool childExited();
+
+        /**
+         * Returns the 8 bit integer value returned from the child program if
+         * childExited returned true.
+         */
+        int childExitStatus();
+
+        /**
+         * Returns true if the child exited because of a signal.
+         */
+        bool childSignaled();
+
+        /**
+         * Returns the signal ID if the childSignaled return true.
+         */
+        int childSignal();
+
+        /**
+         * Returns true if the child left a core dump behind when it exited.
+         */
+        bool childCoreDumped();
+
+    private:
+        class ProcData
+        {
+        public:
+            ProcData();
 #ifdef WIN32
-                        void *hStdIn;
-                        void *hStdOut;
-                        void *hStdErr;
-                        void *hProcess;
+            void *hStdIn;
+            void *hStdOut;
+            void *hStdErr;
+            void *hProcess;
 #else
-                        int iStdIn;
-                        int iStdOut;
-                        int iStdErr;
-                        pid_t iPid;
+            int iStdIn;
+            int iStdOut;
+            int iStdErr;
+            pid_t iPid;
 #endif
-                };
-                ProcData pd;
-                int iProcStatus;
-                bool bBlocking;
-                bool bStdOutEos;
-                bool bStdErrEos;
-
-                void gexec( Flags eFlags, const char *sName, char *const argv[] );
-                void checkClose();
-                Options opt;
-        };
+        };
+        ProcData pd;
+        int iProcStatus;
+        bool bBlocking;
+        bool bStdOutEos;
+        bool bStdErrEos;
+
+        void gexec( Flags eFlags, const char *sName, char *const argv[] );
+        void checkClose();
+        Options opt;
+    };
 }
 
 #endif
diff --git a/src/stable/protocol.h b/src/stable/protocol.h
index 1a02143..4e121d9 100644
--- a/src/stable/protocol.h
+++ b/src/stable/protocol.h
@@ -14,25 +14,25 @@
 
 namespace Bu
 {
-        class Client;
+    class Client;
 
-        /**
-         *@ingroup Serving
-         */
-        class Protocol
-        {
-        public:
-                Protocol();
-                virtual ~Protocol();
+    /**
+     *@ingroup Serving
+     */
+    class Protocol
+    {
+    public:
+        Protocol();
+        virtual ~Protocol();
 
-                virtual void onNewConnection( Bu::Client *pClient );
-                virtual void onNewData( Bu::Client *pClient );
-                virtual void onMessage( Bu::Client *pClient, const Bu::String &sMsg );
-                virtual void onTick( Bu::Client *pClient );
+        virtual void onNewConnection( Bu::Client *pClient );
+        virtual void onNewData( Bu::Client *pClient );
+        virtual void onMessage( Bu::Client *pClient, const Bu::String &sMsg );
+        virtual void onTick( Bu::Client *pClient );
 
-        private:
+    private:
 
-        };
+    };
 }
 
 #endif
diff --git a/src/stable/protocolhttp.cpp b/src/stable/protocolhttp.cpp
index ea1a86e..352f7c7 100644
--- a/src/stable/protocolhttp.cpp
+++ b/src/stable/protocolhttp.cpp
@@ -8,7 +8,7 @@
 #include <dirent.h>
 
 #ifndef WIN32
-        #include <sys/wait.h>
+    #include <sys/wait.h>
 #endif 
 
 #include <errno.h>
@@ -32,9 +32,9 @@ Bu::ProtocolHttp::~ProtocolHttp()
 
 void Bu::ProtocolHttp::onNewConnection( Bu::Client *pClient )
 {
-        this->pClient = pClient;
+    this->pClient = pClient;
 
-        iState = 0;
+    iState = 0;
 }
 
 #define SDB( i ) (void)0
@@ -42,196 +42,196 @@ void Bu::ProtocolHttp::onNewConnection( Bu::Client *pClient )
 
 void Bu::ProtocolHttp::onNewData( Bu::Client *pClient )
 {
-/*      logHexDump(
-                1,
-                pClient->getInput().getStr(),
-                pClient->getInput().getSize(),
-                "input"
-                );*/
-
-        for(;;)
-        {
-                Bu::String sToken;
-                TokenType tt = getToken( sToken );
-
-                if( tt == ttOutOfData )
-                        return;
-
-                switch( iState )
-                {
-                        case 0:         // Start token, should be "method" (get, put, etc)
-                                SDB( 0 );
-                                sMethod = sToken;
-                                iState = 1;
-                                break;
-
-                        case 1:         // The path requested
-                                SDB( 1 );
-                                sPath = sToken;
-                                iState = 2;
-                                break;
-
-                        case 2:         // The protocol name and version
-                                SDB( 2 );
-                                if( strncmp( sToken.getStr(), "HTTP/", 5 ) )
-                                {
-                                        pClient->disconnect();
-                                        return;
-                                }
-                                else
-                                {
-                                        char *s, *s2;
-                                        s = sToken.getStr()+5;
-                                        iMajor = strtol( s, &s2, 10 );
-                                        iMinor = strtol( s2+1, NULL, 10 );
-                                        iState = 3;
-                                }
-                                break;
-
-                        case 3:         // End of initial header, now comes mime-style blocks.
-                                SDB( 3 );
-                                if( tt == ttNewline )
-                                {
-                                        iState = 10;
-                                }
-                                else if( tt == ttDoubleNewline )
-                                {
-                                        earlyResponse();
-                                }
-                                else
-                                {
-                                        pClient->disconnect();
-                                        return;
-                                }
-                                break;
-
-                        case 10:                // HTTP-Message (skipped for now...)
-                                SDB( 10 );
-                                if( tt == ttString )
-                                {
-                                        iState = 11;
-                                }
-                                else
-                                {
-                                        pClient->disconnect();
-                                }
-                                break;
-
-                        case 11:                // Should be a colon...
-                                SDB( 11 );
-                                if( tt == ttSeperator && sToken == ":" )
-                                {
-                                        iState = 12;
-                                }
-                                else
-                                {
-                                        pClient->disconnect();
-                                }
-                                break;
-
-                        case 12:
-                                SDB( 12 );
-                                if( tt == ttNewline )
-                                {
-                                        iState = 10;
-                                }
-                                if( tt == ttDoubleNewline )
-                                {
-                                        earlyResponse();
-                                }
-                                break;
-
-                        case 20:
-                                SDB( 20 );
-                                break;
-                }
-        }
+/*  logHexDump(
+        1,
+        pClient->getInput().getStr(),
+        pClient->getInput().getSize(),
+        "input"
+        );*/
+
+    for(;;)
+    {
+        Bu::String sToken;
+        TokenType tt = getToken( sToken );
+
+        if( tt == ttOutOfData )
+            return;
+
+        switch( iState )
+        {
+            case 0:     // Start token, should be "method" (get, put, etc)
+                SDB( 0 );
+                sMethod = sToken;
+                iState = 1;
+                break;
+
+            case 1:     // The path requested
+                SDB( 1 );
+                sPath = sToken;
+                iState = 2;
+                break;
+
+            case 2:     // The protocol name and version
+                SDB( 2 );
+                if( strncmp( sToken.getStr(), "HTTP/", 5 ) )
+                {
+                    pClient->disconnect();
+                    return;
+                }
+                else
+                {
+                    char *s, *s2;
+                    s = sToken.getStr()+5;
+                    iMajor = strtol( s, &s2, 10 );
+                    iMinor = strtol( s2+1, NULL, 10 );
+                    iState = 3;
+                }
+                break;
+
+            case 3:     // End of initial header, now comes mime-style blocks.
+                SDB( 3 );
+                if( tt == ttNewline )
+                {
+                    iState = 10;
+                }
+                else if( tt == ttDoubleNewline )
+                {
+                    earlyResponse();
+                }
+                else
+                {
+                    pClient->disconnect();
+                    return;
+                }
+                break;
+
+            case 10:        // HTTP-Message (skipped for now...)
+                SDB( 10 );
+                if( tt == ttString )
+                {
+                    iState = 11;
+                }
+                else
+                {
+                    pClient->disconnect();
+                }
+                break;
+
+            case 11:        // Should be a colon...
+                SDB( 11 );
+                if( tt == ttSeperator && sToken == ":" )
+                {
+                    iState = 12;
+                }
+                else
+                {
+                    pClient->disconnect();
+                }
+                break;
+
+            case 12:
+                SDB( 12 );
+                if( tt == ttNewline )
+                {
+                    iState = 10;
+                }
+                if( tt == ttDoubleNewline )
+                {
+                    earlyResponse();
+                }
+                break;
+
+            case 20:
+                SDB( 20 );
+                break;
+        }
+    }
 }
 
 Bu::ProtocolHttp::TokenType Bu::ProtocolHttp::getToken( Bu::String &line )
 {
-        char s;
-        int jmax = pClient->getInputSize();
-        bool bNonWS = false;
-        
-        for( int j = 0; j < jmax; j++ )
-        {
-                pClient->peek( &s, 1, j );
-                if( iState > 2 && isSeperator( s ) )
-                {
-                        if( j == 0 )
-                        {
-                                line += s;
-                                pClient->seek( 1 );
-                                return ttSeperator;
-                        }
-                        else
-                        {
-                                pClient->seek( j );
-                                return ttString;
-                        }
-                }
-                else if( isWS( s ) )
-                {
-                        if( bNonWS )
-                        {
-                                pClient->seek( j );
-                                return ttString;
-                        }
-                }
-                else if( s == CR )
-                {
-                        if( pClient->getInputSize() < 4 )
-                                return ttOutOfData;
-                        
-                        char ss[3];
-                        pClient->peek( ss, 3, j+1 );
-                        if( ss[0] == LF && ss[1] != ' ' && ss[1] != '\t' )
-                        {
-                                if( bNonWS )
-                                {
-                                        pClient->seek( j );
-                                        return ttString;
-                                }
-                                else if( ss[1] == CR && ss[2] == LF )
-                                {
-                                        pClient->seek( 4 );
-                                        return ttDoubleNewline;
-                                }
-                                else
-                                {
-                                        pClient->seek( 2 );
-                                        return ttNewline;
-                                }
-                        }
-                        
-                        j += 2;
-                        if( bNonWS )
-                        {
-                                pClient->seek( j );
-                                return ttString;
-                        }
-                }
-                else
-                {
-                        line += s;
-                        bNonWS = true;
-                }
-        }
-
-        return ttOutOfData;
+    char s;
+    int jmax = pClient->getInputSize();
+    bool bNonWS = false;
+    
+    for( int j = 0; j < jmax; j++ )
+    {
+        pClient->peek( &s, 1, j );
+        if( iState > 2 && isSeperator( s ) )
+        {
+            if( j == 0 )
+            {
+                line += s;
+                pClient->seek( 1 );
+                return ttSeperator;
+            }
+            else
+            {
+                pClient->seek( j );
+                return ttString;
+            }
+        }
+        else if( isWS( s ) )
+        {
+            if( bNonWS )
+            {
+                pClient->seek( j );
+                return ttString;
+            }
+        }
+        else if( s == CR )
+        {
+            if( pClient->getInputSize() < 4 )
+                return ttOutOfData;
+            
+            char ss[3];
+            pClient->peek( ss, 3, j+1 );
+            if( ss[0] == LF && ss[1] != ' ' && ss[1] != '\t' )
+            {
+                if( bNonWS )
+                {
+                    pClient->seek( j );
+                    return ttString;
+                }
+                else if( ss[1] == CR && ss[2] == LF )
+                {
+                    pClient->seek( 4 );
+                    return ttDoubleNewline;
+                }
+                else
+                {
+                    pClient->seek( 2 );
+                    return ttNewline;
+                }
+            }
+            
+            j += 2;
+            if( bNonWS )
+            {
+                pClient->seek( j );
+                return ttString;
+            }
+        }
+        else
+        {
+            line += s;
+            bNonWS = true;
+        }
+    }
+
+    return ttOutOfData;
 }
 
 bool Bu::ProtocolHttp::isWS( char buf )
 {
-        return (buf == ' ' || buf == '\t');
+    return (buf == ' ' || buf == '\t');
 }
 
 bool Bu::ProtocolHttp::isSeperator( char buf )
 {
-        return (buf == '(' || buf == ')' || buf == '<' || buf == '>' ||
-                        buf == '@' || buf == ',' || buf == ';' || buf == ':' ||
-                        buf == '\\' || buf == '\"' || buf == '/' || buf == '[' ||
+    return (buf == '(' || buf == ')' || buf == '<' || buf == '>' ||
+            buf == '@' || buf == ',' || buf == ';' || buf == ':' ||
+            buf == '\\' || buf == '\"' || buf == '/' || buf == '[' ||
                         buf == ']' || buf == '?' || buf == '=' || buf == '{' ||
                         buf == '}' );
 }
diff --git a/src/stable/protocolhttp.h b/src/stable/protocolhttp.h
index 87dc49b..51ca58c 100644
--- a/src/stable/protocolhttp.h
+++ b/src/stable/protocolhttp.h
@@ -18,89 +18,89 @@
 
 namespace Bu
 {
-        /**
-         * An HTTP Protocol handler.  Yes, I know that HTTP stands for Hyper Text
-         * Transfer Protocol, and that the Protocol part is redundant, but in this
-         * case the word Protocol is refering to the Libbu++ construct Bu::Protocol,
-         * and not a means of encoding conversations.  Anyway, this class represents
-         * a general HTTP server processor.  Every time a request comes in it calls
-         * the onRequest function in a subclass with the method and URI that were
-         * requested.  The sub-class can then do whatever it needs to to send back
-         * a response.
-         *@ingroup Serving
-         */
-        class ProtocolHttp : public Protocol
-        {
-        public: /* Types */
-                typedef Bu::List<Bu::String> TokenList;
+    /**
+     * An HTTP Protocol handler.  Yes, I know that HTTP stands for Hyper Text
+     * Transfer Protocol, and that the Protocol part is redundant, but in this
+     * case the word Protocol is refering to the Libbu++ construct Bu::Protocol,
+     * and not a means of encoding conversations.  Anyway, this class represents
+     * a general HTTP server processor.  Every time a request comes in it calls
+     * the onRequest function in a subclass with the method and URI that were
+     * requested.  The sub-class can then do whatever it needs to to send back
+     * a response.
+     *@ingroup Serving
+     */
+    class ProtocolHttp : public Protocol
+    {
+    public: /* Types */
+        typedef Bu::List<Bu::String> TokenList;
 
-        public: /* Interface */
-                ProtocolHttp();
-                virtual ~ProtocolHttp();
+    public: /* Interface */
+        ProtocolHttp();
+        virtual ~ProtocolHttp();
 
-                virtual void onNewConnection( Bu::Client *pClient );
-                virtual void onNewData( Bu::Client *pClient );
+        virtual void onNewConnection( Bu::Client *pClient );
+        virtual void onNewData( Bu::Client *pClient );
 
-                virtual void onRequest(
-                        const Bu::String &sMethod, const Bu::String &sPath )=0;
+        virtual void onRequest(
+            const Bu::String &sMethod, const Bu::String &sPath )=0;
 
-                class Response
-                {
-                        friend class Bu::ProtocolHttp;
-                public:
-                        Response( int iCode );
-                        Response( int iCode, const Bu::String &sReason );
-                        virtual ~Response();
+        class Response
+        {
+            friend class Bu::ProtocolHttp;
+        public:
+            Response( int iCode );
+            Response( int iCode, const Bu::String &sReason );
+            virtual ~Response();
 
-                        void setHeader( const Bu::String &sKey, const Bu::String &sVal );
-                        void setContent( const Bu::String &sCont );
+            void setHeader( const Bu::String &sKey, const Bu::String &sVal );
+            void setContent( const Bu::String &sCont );
 
-                private:
-                        int iCode;
-                        Bu::String sReason;
-                        typedef Bu::Hash<Bu::String,Bu::String> StringHash;
-                        StringHash hHeaders;
-                        Bu::String sContent;
-                };
-                
-                void sendResponse( const Response &rRes );
-        
-        private:
-                enum TokenType
-                {
-                        ttOutOfData,
-                        ttString,
-                        ttNewline,
-                        ttDoubleNewline,
-                        ttSeperator
-                };
-                /**
-                 * Read an HTTP line, this is up to the first CRLF that isn't followed
-                 * by a continuation character, converting it to one line as it reads.
-                 *@param line All data read will be appended to line, even if no
-                 * end-of-line is read.
-                 *@returns True if an end-of-line is read and the line should be
-                 * processed, false if the end-of-line has not been reached, and more
-                 * data needs to be read before this operation can continue.
-                 */
-                TokenType getToken( Bu::String &line );
-                bool isWS( char buf );
-                bool isSeperator( char buf );
+        private:
+            int iCode;
+            Bu::String sReason;
+            typedef Bu::Hash<Bu::String,Bu::String> StringHash;
+            StringHash hHeaders;
+            Bu::String sContent;
+        };
+        
+        void sendResponse( const Response &rRes );
+    
+    private:
+        enum TokenType
+        {
+            ttOutOfData,
+            ttString,
+            ttNewline,
+            ttDoubleNewline,
+            ttSeperator
+        };
+        /**
+         * Read an HTTP line, this is up to the first CRLF that isn't followed
+         * by a continuation character, converting it to one line as it reads.
+         *@param line All data read will be appended to line, even if no
+         * end-of-line is read.
+         *@returns True if an end-of-line is read and the line should be
+         * processed, false if the end-of-line has not been reached, and more
+         * data needs to be read before this operation can continue.
+         */
+        TokenType getToken( Bu::String &line );
+        bool isWS( char buf );
+        bool isSeperator( char buf );
 
-                void earlyResponse();
-                void lateResponse();
+        void earlyResponse();
+        void lateResponse();
 
-        private: /* state */
-                Bu::Client *pClient;
-                TokenList lTokens;
+    private: /* state */
+        Bu::Client *pClient;
+        TokenList lTokens;
 
-                int iState;
+        int iState;
 
-                Bu::String sMethod;
-                Bu::String sPath;
-                int iMajor;
-                int iMinor;
-        };
+        Bu::String sMethod;
+        Bu::String sPath;
+        int iMajor;
+        int iMinor;
+    };
 }
 
 #endif
diff --git a/src/stable/protocoltelnet.cpp b/src/stable/protocoltelnet.cpp
index aed23be..d5465d1 100644
--- a/src/stable/protocoltelnet.cpp
+++ b/src/stable/protocoltelnet.cpp
@@ -11,53 +11,53 @@
 /* We apparently at least want defs for the lower 13, not sure we care about
  * the rest of the chars, maybe escape.
  */
-#define CH_NUL          '\x00'  /* NUL */
-#define CH_SOH          '\x01'  /* Start Of Heading */
-#define CH_STX          '\x02'  /* Start of Text */
-#define CH_ETX          '\x03'  /* End of Text */
-#define CH_EOT          '\x04'  /* End of transmission */
-#define CH_ENQ          '\x05'  /* Enquiery */
-#define CH_ACK          '\x06'  /* Acknowledge */
-#define CH_BEL          '\x07'  /* Bell */
-#define CH_BS           '\x08'  /* Backspace */
-#define CH_TAB          '\x09'  /* Horizontal Tab */
-#define CH_LF           '\x0A'  /* NL Line feed, new line */
-#define CH_VT           '\x0B'  /* Vertical Tab */
-#define CH_FF           '\x0C'  /* Form feed, new page */
-#define CH_CR           '\x0D'  /* Carriage return */
-#define CH_ESC          '\x1B'  /* Escape */
-#define CH_DEL          '\x7F'  /* Delete */
-
-#define CODE_SE         '\xf0'  /* End of subnegotiation params. */
-#define CODE_NOP        '\xf1'  /* No operation (keep-alive). */
-#define CODE_DM         '\xf2'  /* Datastream side of a Synch. */
-#define CODE_BRK        '\xf3'  /* Break character. */
-#define CODE_IP         '\xf4'  /* Interrupt Process character. */
-#define CODE_AO         '\xf5'  /* Abort Output character. */
-#define CODE_AYT        '\xf6'  /* Are You There? character. */
-#define CODE_EC         '\xf7'  /* Erase Character character. */
-#define CODE_EL         '\xf8'  /* Erase Line character. */
-#define CODE_GA         '\xf9'  /* Go Ahead signal. */
-#define CODE_SB         '\xfa'  /* Begin subnegotiation options. */
-#define CODE_WILL       '\xfb'  /* Desire to do something. */
-#define CODE_WONT       '\xfc'  /* Refuse to perform. */
-#define CODE_DO         '\xfd'  /* Request option. */
-#define CODE_DONT       '\xfe'  /* Demand a stop. */
-
-#define CODE_IAC        '\xff'  /* Interpret-As-Command. */
-
-#define OPT_BINARY      '\x00'  /* Binary mode (file transfers?). */
-#define OPT_ECHO        '\x01'  /* (local) Echo mode. */
-#define OPT_SUPGA       '\x03'  /* Suppress Go Ahead signals. */
-#define OPT_STATUS      '\x05'  /* Allow status messages. */
-#define OPT_TIMING      '\x06'  /* Place a timing mark in the code. */
-#define OPT_EXASCII     '\x11'  /* Extended ASCII. */
-#define OPT_LOGOUT      '\x12'  /* Logout. */
-#define OPT_TTYPE       '\x18'  /* Terminal Type. */
-#define OPT_NAWS        '\x1f'  /* Negotiate about window size. */
-#define OPT_TSPEED      '\x20'  /* Terminal Speed. */
-#define OPT_NEWENV      '\x27'  /* New Environment Option. */
-#define OPT_EXOPL       '\xff'  /* Can we, will we, handle extended options. */
+#define CH_NUL      '\x00'  /* NUL */
+#define CH_SOH      '\x01'  /* Start Of Heading */
+#define CH_STX      '\x02'  /* Start of Text */
+#define CH_ETX      '\x03'  /* End of Text */
+#define CH_EOT      '\x04'  /* End of transmission */
+#define CH_ENQ      '\x05'  /* Enquiery */
+#define CH_ACK      '\x06'  /* Acknowledge */
+#define CH_BEL      '\x07'  /* Bell */
+#define CH_BS       '\x08'  /* Backspace */
+#define CH_TAB      '\x09'  /* Horizontal Tab */
+#define CH_LF       '\x0A'  /* NL Line feed, new line */
+#define CH_VT       '\x0B'  /* Vertical Tab */
+#define CH_FF       '\x0C'  /* Form feed, new page */
+#define CH_CR       '\x0D'  /* Carriage return */
+#define CH_ESC      '\x1B'  /* Escape */
+#define CH_DEL      '\x7F'  /* Delete */
+
+#define CODE_SE     '\xf0'  /* End of subnegotiation params. */
+#define CODE_NOP    '\xf1'  /* No operation (keep-alive). */
+#define CODE_DM     '\xf2'  /* Datastream side of a Synch. */
+#define CODE_BRK    '\xf3'  /* Break character. */
+#define CODE_IP     '\xf4'  /* Interrupt Process character. */
+#define CODE_AO     '\xf5'  /* Abort Output character. */
+#define CODE_AYT    '\xf6'  /* Are You There? character. */
+#define CODE_EC     '\xf7'  /* Erase Character character. */
+#define CODE_EL     '\xf8'  /* Erase Line character. */
+#define CODE_GA     '\xf9'  /* Go Ahead signal. */
+#define CODE_SB     '\xfa'  /* Begin subnegotiation options. */
+#define CODE_WILL   '\xfb'  /* Desire to do something. */
+#define CODE_WONT   '\xfc'  /* Refuse to perform. */
+#define CODE_DO     '\xfd'  /* Request option. */
+#define CODE_DONT   '\xfe'  /* Demand a stop. */
+
+#define CODE_IAC    '\xff'  /* Interpret-As-Command. */
+
+#define OPT_BINARY  '\x00'  /* Binary mode (file transfers?). */
+#define OPT_ECHO    '\x01'  /* (local) Echo mode. */
+#define OPT_SUPGA   '\x03'  /* Suppress Go Ahead signals. */
+#define OPT_STATUS  '\x05'  /* Allow status messages. */
+#define OPT_TIMING  '\x06'  /* Place a timing mark in the code. */
+#define OPT_EXASCII '\x11'  /* Extended ASCII. */
+#define OPT_LOGOUT  '\x12'  /* Logout. */
+#define OPT_TTYPE   '\x18'  /* Terminal Type. */
+#define OPT_NAWS    '\x1f'  /* Negotiate about window size. */
+#define OPT_TSPEED  '\x20'  /* Terminal Speed. */
+#define OPT_NEWENV  '\x27'  /* New Environment Option. */
+#define OPT_EXOPL   '\xff'  /* Can we, will we, handle extended options. */
 
 #ifndef __TELNET_DEBUG
 # define printCode( a ) (void)0
@@ -65,12 +65,12 @@
 #endif
 
 Bu::ProtocolTelnet::ProtocolTelnet() :
-        oBinary(        *this, OPT_BINARY ),
-        oEcho(          *this, OPT_ECHO ),
-        oNAWS(          *this, OPT_NAWS ),
-        oSuppressGA(*this, OPT_SUPGA ),
-        bCanonical( true ),
-        bSubOpt( false )
+    oBinary(    *this, OPT_BINARY ),
+    oEcho(      *this, OPT_ECHO ),
+    oNAWS(      *this, OPT_NAWS ),
+    oSuppressGA(*this, OPT_SUPGA ),
+    bCanonical( true ),
+    bSubOpt( false )
 {
 }
 
@@ -80,439 +80,439 @@ Bu::ProtocolTelnet::~ProtocolTelnet()
 
 void Bu::ProtocolTelnet::onNewConnection( Bu::Client *pClient )
 {
-        this->pClient = pClient;
+    this->pClient = pClient;
 }
 
 void Bu::ProtocolTelnet::onNewData( Bu::Client *pClient )
 {
-        char bc;
-        int iLeft;
-        while( (iLeft = pClient->getInputSize()) )
-        {
-                if( bSubOpt )
-                {
-                        pClient->peek( &bc, 1 );
-                        if( bc == CODE_IAC )
-                        {
-                                if( iLeft <= 1 ) return;
-                                char bc2;
-                                printCode( CODE_IAC );
-                                pClient->peek( &bc2, 1, 1 );
-                                printCode( bc2 );
-                                if( bc2 == CODE_SE )
-                                {
-                                        bSubOpt = false;
-                                        onSubOpt();
-                                }
-                                else if( bc2 == CODE_IAC )
-                                {
-                                        sSubBuf += CODE_IAC;
-                                }
-                                else
-                                {
-                                        // Error of some sort.
-                                }
-                                pClient->seek( 1 );
-                        }
-                        else
-                        {
-                                sSubBuf += bc;
-                        }
-                        pClient->seek( 1 );
-                }
-                else
-                {
-                        pClient->peek( &bc, 1 );
-                        if( bc == CODE_IAC )
-                        {
-                                if( iLeft <= 1 ) return;
-                                char bc2;
-                                pClient->peek( &bc2, 1, 1 );
-                                printCode( bc );
-                                printCode( bc2 );
-
-                                switch( bc2 )
-                                {
-                                        case CODE_WILL:
-                                                if( iLeft <= 2 ) return;
-                                                {
-                                                        char bc3;
-                                                        pClient->peek( &bc3, 1, 2 );
-                                                        pClient->seek( 1 );
-                                                        printOpt( bc3 );
-                                                        onWill( bc3 );
-                                                }
-                                                break;
-
-                                        case CODE_WONT:
-                                                if( iLeft <= 2 ) return;
-                                                {
-                                                        char bc3;
-                                                        pClient->peek( &bc3, 1, 2 );
-                                                        pClient->seek( 1 );
-                                                        printOpt( bc3 );
-                                                        onWont( bc3 );
-                                                }
-                                                break;
-
-                                        case CODE_DO:
-                                                if( iLeft <= 2 ) return;
-                                                {
-                                                        char bc3;
-                                                        pClient->peek( &bc3, 1, 2 );
-                                                        pClient->seek( 1 );
-                                                        printOpt( bc3 );
-                                                        onDo( bc3 );
-                                                }
-                                                break;
-
-                                        case CODE_DONT:
-                                                if( iLeft <= 2 ) return;
-                                                {
-                                                        char bc3;
-                                                        pClient->peek( &bc3, 1, 2 );
-                                                        pClient->seek( 1 );
-                                                        printOpt( bc3 );
-                                                        onDont( bc3 );
-                                                }
-                                                break;
-
-                                        case CODE_SB:
-                                                if( iLeft <= 2 ) return;
-                                                {
-                                                        pClient->peek( &cSubOpt, 1, 2 );
-                                                        pClient->seek( 1 );
-                                                        printOpt( cSubOpt );
-                                                        bSubOpt = true;
-                                                }
-                                                break;
-
-                                        case CODE_IAC:
-                                                sDataBuf += CODE_IAC;
-                                                printCode( CODE_IAC );
-                                                break;
-                                }
-                                pClient->seek( 1 );
+    char bc;
+    int iLeft;
+    while( (iLeft = pClient->getInputSize()) )
+    {
+        if( bSubOpt )
+        {
+            pClient->peek( &bc, 1 );
+            if( bc == CODE_IAC )
+            {
+                if( iLeft <= 1 ) return;
+                char bc2;
+                printCode( CODE_IAC );
+                pClient->peek( &bc2, 1, 1 );
+                printCode( bc2 );
+                if( bc2 == CODE_SE )
+                {
+                    bSubOpt = false;
+                    onSubOpt();
+                }
+                else if( bc2 == CODE_IAC )
+                {
+                    sSubBuf += CODE_IAC;
+                }
+                else
+                {
+                    // Error of some sort.
+                }
+                pClient->seek( 1 );
+            }
+            else
+            {
+                sSubBuf += bc;
+            }
+            pClient->seek( 1 );
+        }
+        else
+        {
+            pClient->peek( &bc, 1 );
+            if( bc == CODE_IAC )
+            {
+                if( iLeft <= 1 ) return;
+                char bc2;
+                pClient->peek( &bc2, 1, 1 );
+                printCode( bc );
+                printCode( bc2 );
+
+                switch( bc2 )
+                {
+                    case CODE_WILL:
+                        if( iLeft <= 2 ) return;
+                        {
+                            char bc3;
+                            pClient->peek( &bc3, 1, 2 );
+                            pClient->seek( 1 );
+                            printOpt( bc3 );
+                            onWill( bc3 );
+                        }
+                        break;
+
+                    case CODE_WONT:
+                        if( iLeft <= 2 ) return;
+                        {
+                            char bc3;
+                            pClient->peek( &bc3, 1, 2 );
+                            pClient->seek( 1 );
+                            printOpt( bc3 );
+                            onWont( bc3 );
+                        }
+                        break;
+
+                    case CODE_DO:
+                        if( iLeft <= 2 ) return;
+                        {
+                            char bc3;
+                            pClient->peek( &bc3, 1, 2 );
+                            pClient->seek( 1 );
+                            printOpt( bc3 );
+                            onDo( bc3 );
+                        }
+                        break;
+
+                    case CODE_DONT:
+                        if( iLeft <= 2 ) return;
+                        {
+                            char bc3;
+                            pClient->peek( &bc3, 1, 2 );
+                            pClient->seek( 1 );
+                            printOpt( bc3 );
+                            onDont( bc3 );
+                        }
+                        break;
+
+                    case CODE_SB:
+                        if( iLeft <= 2 ) return;
+                        {
+                            pClient->peek( &cSubOpt, 1, 2 );
+                            pClient->seek( 1 );
+                            printOpt( cSubOpt );
+                            bSubOpt = true;
+                        }
+                        break;
+
+                    case CODE_IAC:
+                        sDataBuf += CODE_IAC;
+                        printCode( CODE_IAC );
+                        break;
+                }
+                pClient->seek( 1 );
 #ifdef __TELNET_DEBUG
-                                printf("\n");
+                printf("\n");
 #endif
-                        }
-                        else if( bc == CODE_SB )
-                        {
-                        }
-                        else
-                        {
-                                // This is where control code handling goes
-                                // Also, possibly, character code conversion, although I'm not
-                                // sure that really matters anymore, go ASCII/UTF-8
-                                if( bCanonical )
-                                {
-                                        if( bc < 0x20 || bc >= CH_DEL )
-                                        {
-                                                if( bc == CH_CR )
-                                                {
-                                                        if( iLeft <= 1 ) return;
-                                                        char bc2;
-                                                        pClient->peek( &bc2, 1, 1 );
-                                                        if( bc2 == CH_NUL || bc2 == CH_LF )
-                                                        {
-                                                                onCtlChar( bc );
-                                                                gotLine( sDataBuf );
-                                                                sDataBuf.clear();
-                                                        }
-                                                        pClient->seek( 1 );
-                                                }
-                                                else
-                                                {
-                                                        onCtlChar( bc );
-                                                }
-                                        }
-                                        else
-                                        {
-                                                sDataBuf += bc;
-                                                if( oEcho.isLocalSet() )
-                                                {
-                                                        pClient->write( &bc, 1 );
+            }
+            else if( bc == CODE_SB )
+            {
+            }
+            else
+            {
+                // This is where control code handling goes
+                // Also, possibly, character code conversion, although I'm not
+                // sure that really matters anymore, go ASCII/UTF-8
+                if( bCanonical )
+                {
+                    if( bc < 0x20 || bc >= CH_DEL )
+                    {
+                        if( bc == CH_CR )
+                        {
+                            if( iLeft <= 1 ) return;
+                            char bc2;
+                            pClient->peek( &bc2, 1, 1 );
+                            if( bc2 == CH_NUL || bc2 == CH_LF )
+                            {
+                                onCtlChar( bc );
+                                gotLine( sDataBuf );
+                                sDataBuf.clear();
+                            }
+                            pClient->seek( 1 );
+                        }
+                        else
+                        {
+                            onCtlChar( bc );
+                        }
+                    }
+                    else
+                    {
+                        sDataBuf += bc;
+                        if( oEcho.isLocalSet() )
+                        {
+                            pClient->write( &bc, 1 );
 #ifdef __TELNET_DEBUG
-                                                        printf("%c", bc );
-                                                        fflush( stdout );
+                            printf("%c", bc );
+                            fflush( stdout );
 #endif
-                                                }
-                                        }
-                                }
-                                else
-                                {
-                                        sDataBuf += bc;
-                                        if( oEcho.isLocalSet() )
-                                        {
-                                                pClient->write( &bc, 1 );
-                                        }
-                                }
-                        }
-                        pClient->seek( 1 );
-                }
-        }
-
-        // It's true, this code will not be executed if we only have half of an
-        // IAC code or multibyte escape sequence or something, but then again, it
-        // shouldn't be called then, and really, shouldn't be, it'll be called soon
-        // enough, when we get the rest of that code.
-        if( !bCanonical )
-        {
-                gotData( sDataBuf );
-        }
+                        }
+                    }
+                }
+                else
+                {
+                    sDataBuf += bc;
+                    if( oEcho.isLocalSet() )
+                    {
+                        pClient->write( &bc, 1 );
+                    }
+                }
+            }
+            pClient->seek( 1 );
+        }
+    }
+
+    // It's true, this code will not be executed if we only have half of an
+    // IAC code or multibyte escape sequence or something, but then again, it
+    // shouldn't be called then, and really, shouldn't be, it'll be called soon
+    // enough, when we get the rest of that code.
+    if( !bCanonical )
+    {
+        gotData( sDataBuf );
+    }
 }
 
 void Bu::ProtocolTelnet::setCanonical( bool bCon )
 {
-        bCanonical = bCon;
+    bCanonical = bCon;
 }
 
 bool Bu::ProtocolTelnet::isCanonical()
 {
-        return bCanonical;
+    return bCanonical;
 }
 
 void Bu::ProtocolTelnet::write( const Bu::String &sData )
 {
-        write( sData.getStr(), sData.getSize() );
+    write( sData.getStr(), sData.getSize() );
 }
 
 void Bu::ProtocolTelnet::write( const char *pData, int iSize )
 {
-        int iLast = 0, j;
-        for( j = iLast; j < iSize; j++ )
-        {
-                if( pData[j] == '\n' )
-                {
-                        if( j+1 >= iSize ||
-                                (pData[j+1] != '\r' && pData[j+1] != '\0') )
-                        {
-                                pClient->write( pData+iLast, j-iLast );
-                                pClient->write( "\n\r", 2 );
-                                iLast = j+1;
-                        }
-                        else
-                        {
-                                j++;
-                        }
-                }
-        }
-        if( j > iLast )
-        {
-                pClient->write( pData+iLast, iSize-iLast );
-        }
-        //pClient->write( pData, iSize );
+    int iLast = 0, j;
+    for( j = iLast; j < iSize; j++ )
+    {
+        if( pData[j] == '\n' )
+        {
+            if( j+1 >= iSize ||
+                (pData[j+1] != '\r' && pData[j+1] != '\0') )
+            {
+                pClient->write( pData+iLast, j-iLast );
+                pClient->write( "\n\r", 2 );
+                iLast = j+1;
+            }
+            else
+            {
+                j++;
+            }
+        }
+    }
+    if( j > iLast )
+    {
+        pClient->write( pData+iLast, iSize-iLast );
+    }
+    //pClient->write( pData, iSize );
 }
 
 void Bu::ProtocolTelnet::write( char cData )
 {
-        write( &cData, 1 );
+    write( &cData, 1 );
 }
 
 void Bu::ProtocolTelnet::onWill( char cCode )
 {
-        try
-        {
-                Option *pOpt = hOpts[cCode];
-                if( pOpt->isRemoteEnabled() )
-                {
-                        pOpt->fOpts |= Option::fRemoteIs;
-                        char buf[3] = { CODE_IAC, CODE_DO, cCode };
-                        pClient->write( buf, 3 );
-                }
-                else
-                {
-                        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                        pClient->write( buf, 3 );
-                }
-
-        }
-        catch( Bu::HashException &e )
-        {
-                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                pClient->write( buf, 3 );
-        }
+    try
+    {
+        Option *pOpt = hOpts[cCode];
+        if( pOpt->isRemoteEnabled() )
+        {
+            pOpt->fOpts |= Option::fRemoteIs;
+            char buf[3] = { CODE_IAC, CODE_DO, cCode };
+            pClient->write( buf, 3 );
+        }
+        else
+        {
+            char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+            pClient->write( buf, 3 );
+        }
+
+    }
+    catch( Bu::HashException &e )
+    {
+        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+        pClient->write( buf, 3 );
+    }
 }
 
 void Bu::ProtocolTelnet::onWont( char cCode )
 {
-        try
-        {
-                Option *pOpt = hOpts[cCode];
-
-                pOpt->fOpts &= ~Option::fRemoteIs;
-                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                pClient->write( buf, 3 );
-        }
-        catch( Bu::HashException &e )
-        {
-                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                pClient->write( buf, 3 );
-        }
+    try
+    {
+        Option *pOpt = hOpts[cCode];
+
+        pOpt->fOpts &= ~Option::fRemoteIs;
+        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+        pClient->write( buf, 3 );
+    }
+    catch( Bu::HashException &e )
+    {
+        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+        pClient->write( buf, 3 );
+    }
 }
 
 void Bu::ProtocolTelnet::onDo( char cCode )
 {
-        try
-        {
-                Option *pOpt = hOpts[cCode];
-                if( pOpt->isLocalEnabled() )
-                {
-                        pOpt->fOpts |= Option::fLocalIs;
-                        char buf[3] = { CODE_IAC, CODE_WILL, cCode };
-                        pClient->write( buf, 3 );
-                }
-                else
-                {
-                        char buf[3] = { CODE_IAC, CODE_WONT, cCode };
-                        pClient->write( buf, 3 );
-                }
-
-        }
-        catch( Bu::HashException &e )
-        {
-                char buf[3] = { CODE_IAC, CODE_WONT, cCode };
-                pClient->write( buf, 3 );
-        }
+    try
+    {
+        Option *pOpt = hOpts[cCode];
+        if( pOpt->isLocalEnabled() )
+        {
+            pOpt->fOpts |= Option::fLocalIs;
+            char buf[3] = { CODE_IAC, CODE_WILL, cCode };
+            pClient->write( buf, 3 );
+        }
+        else
+        {
+            char buf[3] = { CODE_IAC, CODE_WONT, cCode };
+            pClient->write( buf, 3 );
+        }
+
+    }
+    catch( Bu::HashException &e )
+    {
+        char buf[3] = { CODE_IAC, CODE_WONT, cCode };
+        pClient->write( buf, 3 );
+    }
 }
 
 void Bu::ProtocolTelnet::onDont( char cCode )
 {
-        try
-        {
-                Option *pOpt = hOpts[cCode];
-
-                pOpt->fOpts &= ~Option::fLocalIs;
-                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                pClient->write( buf, 3 );
-        }
-        catch( Bu::HashException &e )
-        {
-                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
-                pClient->write( buf, 3 );
-        }
+    try
+    {
+        Option *pOpt = hOpts[cCode];
+
+        pOpt->fOpts &= ~Option::fLocalIs;
+        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+        pClient->write( buf, 3 );
+    }
+    catch( Bu::HashException &e )
+    {
+        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+        pClient->write( buf, 3 );
+    }
 }
 
 void Bu::ProtocolTelnet::onSubOpt()
 {
-        switch( cSubOpt )
-        {
-                case OPT_NAWS:
-                        {
-                                uint16_t iWidth, iHeight;
-                                ((char *)&iWidth)[1] = sSubBuf[0];
-                                ((char *)&iWidth)[0] = sSubBuf[1];
-                                ((char *)&iHeight)[1] = sSubBuf[2];
-                                ((char *)&iHeight)[0] = sSubBuf[3];
-                                onSubNAWS( iWidth, iHeight );
-                        }
-                        break;
-
-                default:
-                        onSubUnknown( cSubOpt, sSubBuf );
-                        break;
-        }
-
-        sSubBuf.clear();
+    switch( cSubOpt )
+    {
+        case OPT_NAWS:
+            {
+                uint16_t iWidth, iHeight;
+                ((char *)&iWidth)[1] = sSubBuf[0];
+                ((char *)&iWidth)[0] = sSubBuf[1];
+                ((char *)&iHeight)[1] = sSubBuf[2];
+                ((char *)&iHeight)[0] = sSubBuf[3];
+                onSubNAWS( iWidth, iHeight );
+            }
+            break;
+
+        default:
+            onSubUnknown( cSubOpt, sSubBuf );
+            break;
+    }
+
+    sSubBuf.clear();
 }
 
 void Bu::ProtocolTelnet::onCtlChar( char cChr )
 {
 #ifdef __TELNET_DEBUG 
-        switch( cChr )
-        {
-                case CH_NUL:    printf("NUL "); break;
-                case CH_SOH:    printf("SOH "); break;
-                case CH_STX:    printf("STX "); break;
-                case CH_ETX:    printf("ETX "); break;
-                case CH_EOT:    printf("EOT "); break;
-                case CH_ENQ:    printf("ENQ "); break;
-                case CH_ACK:    printf("ACK "); break;
-                case CH_BEL:    printf("BEL "); break;
-                case CH_BS:             printf("BS ");  break;
-                case CH_TAB:    printf("TAB "); break;
-                case CH_LF:             printf("LF ");  break;
-                case CH_VT:             printf("VT ");  break;
-                case CH_FF:             printf("FF ");  break;
-                case CH_CR:             printf("CR ");  break;
-                case CH_ESC:    printf("ESC "); break;
-                case CH_DEL:    printf("DEL "); break;
-                default:                printf("!![%02x] ", cChr );     break;
-        }
-        fflush( stdout );
+    switch( cChr )
+    {
+        case CH_NUL:    printf("NUL "); break;
+        case CH_SOH:    printf("SOH "); break;
+        case CH_STX:    printf("STX "); break;
+        case CH_ETX:    printf("ETX "); break;
+        case CH_EOT:    printf("EOT "); break;
+        case CH_ENQ:    printf("ENQ "); break;
+        case CH_ACK:    printf("ACK "); break;
+        case CH_BEL:    printf("BEL "); break;
+        case CH_BS:     printf("BS ");  break;
+        case CH_TAB:    printf("TAB "); break;
+        case CH_LF:     printf("LF ");  break;
+        case CH_VT:     printf("VT ");  break;
+        case CH_FF:     printf("FF ");  break;
+        case CH_CR:     printf("CR ");  break;
+        case CH_ESC:    printf("ESC "); break;
+        case CH_DEL:    printf("DEL "); break;
+        default:        printf("!![%02x] ", cChr ); break;
+    }
+    fflush( stdout );
 #endif
 
-        switch( cChr )
-        {
-                case CH_DEL:
-                        {
-                                if( sDataBuf.getSize() > 0 )
-                                {
-                                        sDataBuf.resize( sDataBuf.getSize()-1 );
-                                        char buf[3] = { CH_BS, ' ', CH_BS };
-                                        pClient->write( buf, 3 );
-                                }
-                        }
-                        break;
-
-        }
+    switch( cChr )
+    {
+        case CH_DEL:
+            {
+                if( sDataBuf.getSize() > 0 )
+                {
+                    sDataBuf.resize( sDataBuf.getSize()-1 );
+                    char buf[3] = { CH_BS, ' ', CH_BS };
+                    pClient->write( buf, 3 );
+                }
+            }
+            break;
+
+    }
 }
 
 #ifdef __TELNET_DEBUG
 void Bu::ProtocolTelnet::printCode( char cCode )
 {
-        switch( cCode )
-        {
-                case CODE_SE:           printf("SE ");          break;
-                case CODE_NOP:          printf("NOP ");         break;
-                case CODE_DM:           printf("DM ");          break;
-                case CODE_BRK:          printf("BRK ");         break;
-                case CODE_IP:           printf("IP ");          break;
-                case CODE_AO:           printf("AO ");          break;
-                case CODE_AYT:          printf("AYT ");         break;
-                case CODE_EC:           printf("EC ");          break;
-                case CODE_EL:           printf("EL ");          break;
-                case CODE_GA:           printf("GA ");          break;
-                case CODE_SB:           printf("SB ");          break;
-                case CODE_WILL:         printf("WILL ");        break;
-                case CODE_WONT:         printf("WONT ");        break;
-                case CODE_DO:           printf("DO ");          break;
-                case CODE_DONT:         printf("DONT ");        break;
-                case CODE_IAC:          printf("IAC ");         break;
-                default:                        printf("??%02x ", cCode );      break;
-        }
-        fflush( stdout );
+    switch( cCode )
+    {
+        case CODE_SE:       printf("SE ");      break;
+        case CODE_NOP:      printf("NOP ");     break;
+        case CODE_DM:       printf("DM ");      break;
+        case CODE_BRK:      printf("BRK ");     break;
+        case CODE_IP:       printf("IP ");      break;
+        case CODE_AO:       printf("AO ");      break;
+        case CODE_AYT:      printf("AYT ");     break;
+        case CODE_EC:       printf("EC ");      break;
+        case CODE_EL:       printf("EL ");      break;
+        case CODE_GA:       printf("GA ");      break;
+        case CODE_SB:       printf("SB ");      break;
+        case CODE_WILL:     printf("WILL ");    break;
+        case CODE_WONT:     printf("WONT ");    break;
+        case CODE_DO:       printf("DO ");      break;
+        case CODE_DONT:     printf("DONT ");    break;
+        case CODE_IAC:      printf("IAC ");     break;
+        default:            printf("??%02x ", cCode );  break;
+    }
+    fflush( stdout );
 }
 
 void Bu::ProtocolTelnet::printOpt( char cOpt )
 {
-        switch( cOpt )
-        {
-                case OPT_BINARY:        printf("BINARY ");      break;
-                case OPT_ECHO:          printf("ECHO ");        break;
-                case OPT_SUPGA:         printf("SUPGA ");       break;
-                case OPT_STATUS:        printf("STATUS ");      break;
-                case OPT_TIMING:        printf("TIMING ");      break;
-                case OPT_EXASCII:       printf("EXASCII ");     break;
-                case OPT_LOGOUT:        printf("LOGOUT ");      break;
-                case OPT_TTYPE:         printf("TTYPE ");       break;
-                case OPT_NAWS:          printf("NAWS ");        break;
-                case OPT_TSPEED:        printf("TSPEED ");      break;
-                case OPT_NEWENV:        printf("NEWENV ");      break;
-                case OPT_EXOPL:         printf("EXOPL ");       break;
-                default:                        printf("??%02x ", cOpt);        break;
-        }
-        fflush( stdout );
+    switch( cOpt )
+    {
+        case OPT_BINARY:    printf("BINARY ");  break;
+        case OPT_ECHO:      printf("ECHO ");    break;
+        case OPT_SUPGA:     printf("SUPGA ");   break;
+        case OPT_STATUS:    printf("STATUS ");  break;
+        case OPT_TIMING:    printf("TIMING ");  break;
+        case OPT_EXASCII:   printf("EXASCII "); break;
+        case OPT_LOGOUT:    printf("LOGOUT ");  break;
+        case OPT_TTYPE:     printf("TTYPE ");   break;
+        case OPT_NAWS:      printf("NAWS ");    break;
+        case OPT_TSPEED:    printf("TSPEED ");  break;
+        case OPT_NEWENV:    printf("NEWENV ");  break;
+        case OPT_EXOPL:     printf("EXOPL ");   break;
+        default:            printf("??%02x ", cOpt);    break;
+    }
+    fflush( stdout );
 }
 #endif
 
 Bu::ProtocolTelnet::Option::Option( Bu::ProtocolTelnet &rPT, char cCode ) :
-        rPT( rPT ),
-        fOpts( 0 ),
-        cCode( cCode )
+    rPT( rPT ),
+    fOpts( 0 ),
+    cCode( cCode )
 {
-        rPT.hOpts.insert( cCode, this );
+    rPT.hOpts.insert( cCode, this );
 }
 
 Bu::ProtocolTelnet::Option::~Option()
@@ -521,100 +521,100 @@ Bu::ProtocolTelnet::Option::~Option()
 
 void Bu::ProtocolTelnet::Option::localEnable( bool bSet )
 {
-        if( bSet == (bool)(!(fOpts&fLocalCant)) ) return;
+    if( bSet == (bool)(!(fOpts&fLocalCant)) ) return;
 
-        if( bSet )
-                fOpts &= ~fLocalCant;
-        else
-                fOpts |= fLocalCant;
+    if( bSet )
+        fOpts &= ~fLocalCant;
+    else
+        fOpts |= fLocalCant;
 }
 
 void Bu::ProtocolTelnet::Option::localSet( bool bSet )
 {
-        if( bSet == (bool)(fOpts&fLocalIs) ) return;
+    if( bSet == (bool)(fOpts&fLocalIs) ) return;
 
-        char buf[3] = { CODE_IAC, 0, cCode };
+    char buf[3] = { CODE_IAC, 0, cCode };
 
-        if( bSet )
-        {
-                buf[1] = CODE_WILL;
-                rPT.pClient->write( buf, 3 );
+    if( bSet )
+    {
+        buf[1] = CODE_WILL;
+        rPT.pClient->write( buf, 3 );
 #ifdef __TELNET_DEBUG
-                printf("<= ");
-                rPT.printCode( buf[0] );
-                rPT.printCode( buf[1] );
-                rPT.printOpt( buf[2] );
-                printf("\n");
+        printf("<= ");
+        rPT.printCode( buf[0] );
+        rPT.printCode( buf[1] );
+        rPT.printOpt( buf[2] );
+        printf("\n");
 #endif
-        }
-        else
-        {
-                buf[1] = CODE_WONT;
-                rPT.pClient->write( buf, 3 );
+    }
+    else
+    {
+        buf[1] = CODE_WONT;
+        rPT.pClient->write( buf, 3 );
 #ifdef __TELNET_DEBUG
-                printf("<= ");
-                rPT.printCode( buf[0] );
-                rPT.printCode( buf[1] );
-                rPT.printOpt( buf[2] );
-                printf("\n");
+        printf("<= ");
+        rPT.printCode( buf[0] );
+        rPT.printCode( buf[1] );
+        rPT.printOpt( buf[2] );
+        printf("\n");
 #endif
-        }
+    }
 }
 
 bool Bu::ProtocolTelnet::Option::isLocalEnabled()
 {
-        return (bool)(!(fOpts&fLocalCant));
+    return (bool)(!(fOpts&fLocalCant));
 }
 
 bool Bu::ProtocolTelnet::Option::isLocalSet()
 {
-        return (bool)(fOpts&fLocalIs);
+    return (bool)(fOpts&fLocalIs);
 }
 
 void Bu::ProtocolTelnet::Option::remoteEnable( bool /*bSet*/ )
 {
-        return;
+    return;
 }
 
 void Bu::ProtocolTelnet::Option::remoteSet( bool bSet )
 {
-        //if( bSet == (bool)(fOpts&fRemoteIs) ) return;
+    //if( bSet == (bool)(fOpts&fRemoteIs) ) return;
 
-        char buf[3] = { CODE_IAC, 0, cCode };
+    char buf[3] = { CODE_IAC, 0, cCode };
 
-        if( bSet )
-        {
-                buf[1] = CODE_DO;
-                rPT.pClient->write( buf, 3 );
+    if( bSet )
+    {
+        buf[1] = CODE_DO;
+        rPT.pClient->write( buf, 3 );
 #ifdef __TELNET_DEBUG
-                printf("<= ");
-                rPT.printCode( buf[0] );
-                rPT.printCode( buf[1] );
-                rPT.printOpt( buf[2] );
-                printf("\n");
+        printf("<= ");
+        rPT.printCode( buf[0] );
+        rPT.printCode( buf[1] );
+        rPT.printOpt( buf[2] );
+        printf("\n");
 #endif
-        }
-        else
-        {
-                buf[1] = CODE_DONT;
-                rPT.pClient->write( buf, 3 );
+    }
+    else
+    {
+        buf[1] = CODE_DONT;
+        rPT.pClient->write( buf, 3 );
 #ifdef __TELNET_DEBUG
-                printf("<= ");
-                rPT.printCode( buf[0] );
-                rPT.printCode( buf[1] );
-                rPT.printOpt( buf[2] );
-                printf("\n");
+        printf("<= ");
+        rPT.printCode( buf[0] );
+        rPT.printCode( buf[1] );
+        rPT.printOpt( buf[2] );
+        printf("\n");
 #endif
-        }
+    }
 }
 
 bool Bu::ProtocolTelnet::Option::isRemoteEnabled()
 {
-        return (bool)(!(fOpts&fRemoteCant));
+    return (bool)(!(fOpts&fRemoteCant));
 }
 
 bool Bu::ProtocolTelnet::Option::isRemoteSet()
 {
-        return (bool)(fOpts&fRemoteIs);
+    return (bool)(fOpts&fRemoteIs);
 }
 
diff --git a/src/stable/protocoltelnet.h b/src/stable/protocoltelnet.h
index 9a13496..b212303 100644
--- a/src/stable/protocoltelnet.h
+++ b/src/stable/protocoltelnet.h
@@ -16,205 +16,205 @@
 
 namespace Bu
 {
-        /**
-         * Telnet Protocol handler.  This attempts to provide useful and general
-         * support for most of the most commonly used Telnet extensions in a simple
-         * and easy to use way.  The Option variables control the settings that can
-         * be used on the line, and control which virtual "callbacks" will be called
-         * when different events happen.
-         *
-         * To setup initial values and to disable any options you wish override the
-         * onNewConnection function in your own class, like this:
-         *@code
-         class MyTelnet : public Bu::ProtocolTelnet
-         {
-         public:
-                ...
-
-                virtual void onNewConnection( class Bu::Client *pClient )
-                {
-                        // Call the parent class' onNewConnection to get everything all
-                        // set up.
-                        Bu::ProtocolTelnet::onNewConnection( pClient );
-
-                        // These functions disable the option to send files via telnet,
-                        // disabling the remote option means that we won't accept this
-                        // option (binary data being sent to us) from the client.
-                        //
-                        // Disabling the local option means that the client cannot ask us
-                        // to send them binary data.
-                        oBinary.enableRemote( false );
-                        oBinary.enableLocal( false );
-
-                        // This requests that the client send us window size updates
-                        // whenever the size of their window changes, and an initial set to
-                        // boot.
-                        //
-                        // To see if this option is set later, try oNAWS.isRemoteSet(), but
-                        // wait a little while, asking immediatly will always return false,
-                        // since the remote side has yet to receive our request.
-                        oNAWS.remoteSet();
-                }
-        }
-         @endcode
-         *
-         *@ingroup Serving
-         */
-        class ProtocolTelnet : public Protocol
-        {
-        public:
-                ProtocolTelnet();
-                virtual ~ProtocolTelnet();
-
-                /**
-                 * If you override this function in a child class, make sure to call
-                 * this version of it as the very first thing that you do, before you
-                 * set any options.  See the example in the class docs.
-                 */
-                virtual void onNewConnection( class Bu::Client *pClient );
-
-                /**
-                 * You should never override this function unless you really, really
-                 * know what you're doing.  If you want to get data after each line
-                 * entered (in canonical mode) or after any data arrives (non canonical
-                 * mode) then override the gotLine and gotData functions, respectively.
-                 */
-                virtual void onNewData( class Bu::Client *pClient );
-
-                /**
-                 * Override this function to be notified of lines being submitted by
-                 * the client.  This function is only called in canonical mode, after
-                 * all edits are performed on the data.  In this mode weather you use
-                 * the line or not, the data will be cleared from the buffer when this
-                 * function returns, any changes made to the buffer will be destroyed.
-                 */
-                virtual void gotLine( Bu::String & /*sLine*/ ){};
-
-                /**
-                 * Override this function to be notified of any new data that comes in
-                 * from the client.  This function is only called in non-canonical mode,
-                 * and includes all raw data minus telnet control codes and ansi
-                 * escape sequences.  In this mode control of the buffer is up to the
-                 * child class in this function, the buffer will never be cleared unless
-                 * it happens in this function's override.
-                 */
-                virtual void gotData( Bu::String & /*sData*/ ){};
-
-                /**
-                 * Using this function to enable or disable canonical mode only affects
-                 * the way the data is processed and which virtual functions are called
-                 * during processing.  It does not affect options set locally or
-                 * remotely.  Setting this to false will enable char-at-a-time mode,
-                 * effectively disabling internal line-editing code.  Characters
-                 * such as backspace that are detected will not be handled and will be
-                 * sent to the user override.  The subclass will also be notified every
-                 * time new data is available, not just whole lines.
-                 *
-                 * When set to true (the default), line editing control codes will be
-                 * interpreted and used, and the subclass will only be notified when
-                 * complete lines are available in the buffer.
-                 */
-                void setCanonical( bool bCon=true );
-                bool isCanonical();
-
-                void write( const Bu::String &sData );
-                void write( const char *pData, int iSize );
-                void write( char cData );
-
-                const Bu::String &getBuffer() { return sDataBuf; }
-
-        public:
-                /**
-                 * If you wish to know the current dimensions of the client window,
-                 * override this function, it will be called whenever the size changes.
-                 */
-                virtual void onSubNAWS( uint16_t /*iWidth*/, uint16_t /*iHeight*/ ){};
-
-                /**
-                 * This function is called whenever an unknown sub negotiation option is
-                 * sent over the line.  This doesn't mean that it's malformatted, it
-                 * just means that this class doesn't support that option yet, but you
-                 * can handle it yourself if you'd like.  Feel free to change the
-                 * sSubBuf, it will be cleared as soon as this function returns anyway.
-                 */
-                virtual void onSubUnknown( char /*cSubOpt*/,
-                        Bu::String & /*sSubBuf*/ ){};
-
-        private:
-                /**
-                 * Represents a basic telnet option, either on or off, no parameters.
-                 * Each Option can negotiate effectively on it's own, and has two
-                 * parameters in each of two classes.  Both local and remote can be
-                 * enabled/disabled and set/unset.  Enabled represents the ability to
-                 * set the option, disabling an option should also unset it.  Set or
-                 * unset represent wether the option is being used, if it is allowed.
-                 */
-                class Option
-                {
-                        friend class Bu::ProtocolTelnet;
-                private:
-                        Option( ProtocolTelnet &rPT, char cCode );
-                        virtual ~Option();
-
-                public:
-                        void localEnable( bool bSet=true );
-                        void localSet( bool bSet=true );
-                        
-                        bool isLocalEnabled();
-                        bool isLocalSet();
-                        
-                        void remoteEnable( bool bSet=true );
-                        void remoteSet( bool bSet=true );
-
-                        bool isRemoteEnabled();
-                        bool isRemoteSet();
-
-                private:
-                        enum
-                        {
-                                fLocalCant      = 0x01, /**< Local can't/won't allow option. */
-                                fLocalIs        = 0x02, /**< Local is using option. */
-                                fRemoteCant     = 0x04, /**< Remote can't/won't allow option. */
-                                fRemoteIs       = 0x08  /**< Remote is using option. */
-                        };
-
-                        ProtocolTelnet &rPT;
-                        char fOpts;
-                        char cCode;
-                };
-                friend class Bu::ProtocolTelnet::Option;
-
-                Hash<char, Option *> hOpts;
-
-        public:
-                Option oBinary;
-                Option oEcho;
-                Option oNAWS;
-                Option oSuppressGA;
-
-        private:
-                void onWill( char cCode );
-                void onWont( char cCode );
-                void onDo( char cCode );
-                void onDont( char cCode );
-                void onSubOpt();
-                void onCtlChar( char cChr );
+    /**
+     * Telnet Protocol handler.  This attempts to provide useful and general
+     * support for most of the most commonly used Telnet extensions in a simple
+     * and easy to use way.  The Option variables control the settings that can
+     * be used on the line, and control which virtual "callbacks" will be called
+     * when different events happen.
+     *
+     * To setup initial values and to disable any options you wish override the
+     * onNewConnection function in your own class, like this:
+     *@code
+     class MyTelnet : public Bu::ProtocolTelnet
+     {
+     public:
+        ...
+
+        virtual void onNewConnection( class Bu::Client *pClient )
+        {
+            // Call the parent class' onNewConnection to get everything all
+            // set up.
+            Bu::ProtocolTelnet::onNewConnection( pClient );
+
+            // These functions disable the option to send files via telnet,
+            // disabling the remote option means that we won't accept this
+            // option (binary data being sent to us) from the client.
+            //
+            // Disabling the local option means that the client cannot ask us
+            // to send them binary data.
+            oBinary.enableRemote( false );
+            oBinary.enableLocal( false );
+
+            // This requests that the client send us window size updates
+            // whenever the size of their window changes, and an initial set to
+            // boot.
+            //
+            // To see if this option is set later, try oNAWS.isRemoteSet(), but
+            // wait a little while, asking immediatly will always return false,
+            // since the remote side has yet to receive our request.
+            oNAWS.remoteSet();
+        }
+    }
+     @endcode
+     *
+     *@ingroup Serving
+     */
+    class ProtocolTelnet : public Protocol
+    {
+    public:
+        ProtocolTelnet();
+        virtual ~ProtocolTelnet();
+
+        /**
+         * If you override this function in a child class, make sure to call
+         * this version of it as the very first thing that you do, before you
+         * set any options.  See the example in the class docs.
+         */
+        virtual void onNewConnection( class Bu::Client *pClient );
+
+        /**
+         * You should never override this function unless you really, really
+         * know what you're doing.  If you want to get data after each line
+         * entered (in canonical mode) or after any data arrives (non canonical
+         * mode) then override the gotLine and gotData functions, respectively.
+         */
+        virtual void onNewData( class Bu::Client *pClient );
+
+        /**
+         * Override this function to be notified of lines being submitted by
+         * the client.  This function is only called in canonical mode, after
+         * all edits are performed on the data.  In this mode weather you use
+         * the line or not, the data will be cleared from the buffer when this
+         * function returns, any changes made to the buffer will be destroyed.
+         */
+        virtual void gotLine( Bu::String & /*sLine*/ ){};
+
+        /**
+         * Override this function to be notified of any new data that comes in
+         * from the client.  This function is only called in non-canonical mode,
+         * and includes all raw data minus telnet control codes and ansi
+         * escape sequences.  In this mode control of the buffer is up to the
+         * child class in this function, the buffer will never be cleared unless
+         * it happens in this function's override.
+         */
+        virtual void gotData( Bu::String & /*sData*/ ){};
+
+        /**
+         * Using this function to enable or disable canonical mode only affects
+         * the way the data is processed and which virtual functions are called
+         * during processing.  It does not affect options set locally or
+         * remotely.  Setting this to false will enable char-at-a-time mode,
+         * effectively disabling internal line-editing code.  Characters
+         * such as backspace that are detected will not be handled and will be
+         * sent to the user override.  The subclass will also be notified every
+         * time new data is available, not just whole lines.
+         *
+         * When set to true (the default), line editing control codes will be
+         * interpreted and used, and the subclass will only be notified when
+         * complete lines are available in the buffer.
+         */
+        void setCanonical( bool bCon=true );
+        bool isCanonical();
+
+        void write( const Bu::String &sData );
+        void write( const char *pData, int iSize );
+        void write( char cData );
+
+        const Bu::String &getBuffer() { return sDataBuf; }
+
+    public:
+        /**
+         * If you wish to know the current dimensions of the client window,
+         * override this function, it will be called whenever the size changes.
+         */
+        virtual void onSubNAWS( uint16_t /*iWidth*/, uint16_t /*iHeight*/ ){};
+
+        /**
+         * This function is called whenever an unknown sub negotiation option is
+         * sent over the line.  This doesn't mean that it's malformatted, it
+         * just means that this class doesn't support that option yet, but you
+         * can handle it yourself if you'd like.  Feel free to change the
+         * sSubBuf, it will be cleared as soon as this function returns anyway.
+         */
+        virtual void onSubUnknown( char /*cSubOpt*/,
+            Bu::String & /*sSubBuf*/ ){};
+
+    private:
+        /**
+         * Represents a basic telnet option, either on or off, no parameters.
+         * Each Option can negotiate effectively on it's own, and has two
+         * parameters in each of two classes.  Both local and remote can be
+         * enabled/disabled and set/unset.  Enabled represents the ability to
+         * set the option, disabling an option should also unset it.  Set or
+         * unset represent wether the option is being used, if it is allowed.
+         */
+        class Option
+        {
+            friend class Bu::ProtocolTelnet;
+        private:
+            Option( ProtocolTelnet &rPT, char cCode );
+            virtual ~Option();
+
+        public:
+            void localEnable( bool bSet=true );
+            void localSet( bool bSet=true );
+            
+            bool isLocalEnabled();
+            bool isLocalSet();
+            
+            void remoteEnable( bool bSet=true );
+            void remoteSet( bool bSet=true );
+
+            bool isRemoteEnabled();
+            bool isRemoteSet();
+
+        private:
+            enum
+            {
+                fLocalCant  = 0x01, /**< Local can't/won't allow option. */
+                fLocalIs    = 0x02, /**< Local is using option. */
+                fRemoteCant = 0x04, /**< Remote can't/won't allow option. */
+                fRemoteIs   = 0x08  /**< Remote is using option. */
+            };
+
+            ProtocolTelnet &rPT;
+            char fOpts;
+            char cCode;
+        };
+        friend class Bu::ProtocolTelnet::Option;
+
+        Hash<char, Option *> hOpts;
+
+    public:
+        Option oBinary;
+        Option oEcho;
+        Option oNAWS;
+        Option oSuppressGA;
+
+    private:
+        void onWill( char cCode );
+        void onWont( char cCode );
+        void onDo( char cCode );
+        void onDont( char cCode );
+        void onSubOpt();
+        void onCtlChar( char cChr );
 
 #ifdef __TELNET_DEBUG
-                void printCode( char cCode );
-                void printOpt( char cOpt );
+        void printCode( char cCode );
+        void printOpt( char cOpt );
 #endif
 
-        private:
-                Client *pClient;
+    private:
+        Client *pClient;
 
-                Bu::String sDataBuf;    /**< Buffer for regular line data. */
-                Bu::String sSubBuf;     /**< Buffer for subnegotiation data. */
-                char cSubOpt;   /**< Which suboption are we processing. */
+        Bu::String sDataBuf;    /**< Buffer for regular line data. */
+        Bu::String sSubBuf; /**< Buffer for subnegotiation data. */
+        char cSubOpt;   /**< Which suboption are we processing. */
 
-                bool bCanonical;        /**< Are we canonicalizing incoming data? */
-                bool bSubOpt;           /**< Are we processing a suboption right now? */
-        };
+        bool bCanonical;    /**< Are we canonicalizing incoming data? */
+        bool bSubOpt;       /**< Are we processing a suboption right now? */
+    };
 }
 
 #endif
diff --git a/src/stable/queue.h b/src/stable/queue.h
index a5f41e9..213d508 100644
--- a/src/stable/queue.h
+++ b/src/stable/queue.h
@@ -10,31 +10,31 @@
 
 namespace Bu
 {
-        /**
-         * Queue abstract baseclass
-         */
-        template<typename value>
-        class Queue
-        {
-        public:
-                Queue()
-                {
-                }
+    /**
+     * Queue abstract baseclass
+     */
+    template<typename value>
+    class Queue
+    {
+    public:
+        Queue()
+        {
+        }
 
-                virtual ~Queue()
-                {
-                }
+        virtual ~Queue()
+        {
+        }
 
-                virtual void enqueue( const value &i )=0;
-                virtual value dequeue()=0;
-                virtual value &peek()=0;
-                virtual const value &peek() const=0;
-                virtual bool isEmpty() const=0;
-                virtual int getSize() const=0;
+        virtual void enqueue( const value &i )=0;
+        virtual value dequeue()=0;
+        virtual value &peek()=0;
+        virtual const value &peek() const=0;
+        virtual bool isEmpty() const=0;
+        virtual int getSize() const=0;
 
-        private:
+    private:
 
-        };
+    };
 }
 
 #endif
diff --git a/src/stable/queuebuf.cpp b/src/stable/queuebuf.cpp
index 8a3397f..2d49684 100644
--- a/src/stable/queuebuf.cpp
+++ b/src/stable/queuebuf.cpp
@@ -11,181 +11,181 @@
 using Bu::sio;
 
 Bu::QueueBuf::QueueBuf( int iBlockSize /*=256*/ ) :
-        iBlockSize( iBlockSize ),
-        iReadOffset( 0 ),
-        iWriteOffset( 0 ),
-        iTotalSize( 0 )
+    iBlockSize( iBlockSize ),
+    iReadOffset( 0 ),
+    iWriteOffset( 0 ),
+    iTotalSize( 0 )
 {
 }
 
 Bu::QueueBuf::~QueueBuf()
 {
-        for( BlockList::iterator i = lBlocks.begin(); i; i++ )
-                delete[] *i;
+    for( BlockList::iterator i = lBlocks.begin(); i; i++ )
+        delete[] *i;
 }
 
 void Bu::QueueBuf::close()
 {
-        for( BlockList::iterator i = lBlocks.begin(); i; i++ )
-                delete[] *i;
-        lBlocks.clear();
-        iReadOffset = iWriteOffset = iTotalSize = 0;
+    for( BlockList::iterator i = lBlocks.begin(); i; i++ )
+        delete[] *i;
+    lBlocks.clear();
+    iReadOffset = iWriteOffset = iTotalSize = 0;
 }
 
 Bu::size Bu::QueueBuf::read( void *pRawBuf, Bu::size nBytes )
 {
-        if( nBytes <= 0 )
-                return 0;
-
-        if( lBlocks.isEmpty() )
-                return 0;
-
-        Bu::size iLeft = nBytes;
-        char *pBuf = (char *)pRawBuf;
-
-        while( iLeft > 0 && iTotalSize > 0 )
-        {
-                if( iReadOffset == iBlockSize )
-                {
-                        removeBlock();
-                        if( lBlocks.isEmpty() )
-                        {
-                                return nBytes-iLeft;
-                        }
-                        iReadOffset = 0;
-                }
-                char *pBlock = lBlocks.first();
-                Bu::size iCopy = iBlockSize-iReadOffset;
-                if( iLeft < iCopy )
-                        iCopy = iLeft;
-                if( iTotalSize < iCopy )
-                        iCopy = iTotalSize;
-                memcpy( pBuf, pBlock+iReadOffset, iCopy );
-                iReadOffset += iCopy;
-                iLeft -= iCopy;
-                pBuf += iCopy;
-                iTotalSize -= iCopy;
-//              sio << "Read " << iCopy << " bytes, new size: " << iTotalSize << sio.nl;
-        }
-
-        return nBytes - iLeft;
+    if( nBytes <= 0 )
+        return 0;
+
+    if( lBlocks.isEmpty() )
+        return 0;
+
+    Bu::size iLeft = nBytes;
+    char *pBuf = (char *)pRawBuf;
+
+    while( iLeft > 0 && iTotalSize > 0 )
+    {
+        if( iReadOffset == iBlockSize )
+        {
+            removeBlock();
+            if( lBlocks.isEmpty() )
+            {
+                return nBytes-iLeft;
+            }
+            iReadOffset = 0;
+        }
+        char *pBlock = lBlocks.first();
+        Bu::size iCopy = iBlockSize-iReadOffset;
+        if( iLeft < iCopy )
+            iCopy = iLeft;
+        if( iTotalSize < iCopy )
+            iCopy = iTotalSize;
+        memcpy( pBuf, pBlock+iReadOffset, iCopy );
+        iReadOffset += iCopy;
+        iLeft -= iCopy;
+        pBuf += iCopy;
+        iTotalSize -= iCopy;
+//      sio << "Read " << iCopy << " bytes, new size: " << iTotalSize << sio.nl;
+    }
+
+    return nBytes - iLeft;
 }
 
 Bu::size Bu::QueueBuf::peek( void *pBuf, Bu::size nBytes )
 {
-        return peek( pBuf, nBytes, 0 );
+    return peek( pBuf, nBytes, 0 );
 }
 
 Bu::size Bu::QueueBuf::peek( void *pRawBuf, Bu::size nBytes, Bu::size nSkip )
 {
-        if( nBytes <= 0 )
-                return 0;
-
-        if( lBlocks.isEmpty() )
-                return 0;
-
-        Bu::size iLeft = nBytes;
-        char *pBuf = (char *)pRawBuf;
-
-        int iTmpReadOffset = iReadOffset + nSkip;
-        Bu::size iTmpRemSize = iTotalSize;
-        BlockList::iterator iBlock = lBlocks.begin();
-        while( iTmpReadOffset > iBlockSize )
-        {
-                iTmpReadOffset -= iBlockSize;
-                iBlock++;
-        }
-        while( iLeft > 0 && iTmpRemSize > 0 )
-        {
-                if( iTmpReadOffset == iBlockSize )
-                {
-                        iBlock++;
-                        if( iBlock == lBlocks.end() )
-                        {
-                                return nBytes-iLeft;
-                        }
-                        iTmpReadOffset = 0;
-                }
-                char *pBlock = *iBlock;
-                Bu::size iCopy = iBlockSize-iTmpReadOffset;
-                if( iLeft < iCopy )
-                        iCopy = iLeft;
-                if( iTmpRemSize < iCopy )
-                        iCopy = iTmpRemSize;
-                memcpy( pBuf, pBlock+iTmpReadOffset, iCopy );
-                iTmpReadOffset += iCopy;
-                iLeft -= iCopy;
-                pBuf += iCopy;
-                iTmpRemSize -= iCopy;
-//              sio << "Read (peek) " << iCopy << " bytes, new temp size: "
-//                      << iTmpRemSize << sio.nl;
-        }
-
-        return nBytes - iLeft;
+    if( nBytes <= 0 )
+        return 0;
+
+    if( lBlocks.isEmpty() )
+        return 0;
+
+    Bu::size iLeft = nBytes;
+    char *pBuf = (char *)pRawBuf;
+
+    int iTmpReadOffset = iReadOffset + nSkip;
+    Bu::size iTmpRemSize = iTotalSize;
+    BlockList::iterator iBlock = lBlocks.begin();
+    while( iTmpReadOffset > iBlockSize )
+    {
+        iTmpReadOffset -= iBlockSize;
+        iBlock++;
+    }
+    while( iLeft > 0 && iTmpRemSize > 0 )
+    {
+        if( iTmpReadOffset == iBlockSize )
+        {
+            iBlock++;
+            if( iBlock == lBlocks.end() )
+            {
+                return nBytes-iLeft;
+            }
+            iTmpReadOffset = 0;
+        }
+        char *pBlock = *iBlock;
+        Bu::size iCopy = iBlockSize-iTmpReadOffset;
+        if( iLeft < iCopy )
+            iCopy = iLeft;
+        if( iTmpRemSize < iCopy )
+            iCopy = iTmpRemSize;
+        memcpy( pBuf, pBlock+iTmpReadOffset, iCopy );
+        iTmpReadOffset += iCopy;
+        iLeft -= iCopy;
+        pBuf += iCopy;
+        iTmpRemSize -= iCopy;
+//      sio << "Read (peek) " << iCopy << " bytes, new temp size: "
+//          << iTmpRemSize << sio.nl;
+    }
+
+    return nBytes - iLeft;
 }
 
 Bu::size Bu::QueueBuf::write( const void *pRawBuf, Bu::size nBytes )
 {
-        if( nBytes <= 0 )
-                return 0;
-
-        if( lBlocks.isEmpty() )
-        {
-                addBlock();
-                iWriteOffset = 0;
-        }
-        Bu::size iLeft = nBytes;
-        const char *pBuf = (const char *)pRawBuf;
-
-        while( iLeft > 0 )
-        {
-                if( iWriteOffset == iBlockSize )
-                {
-                        addBlock();
-                        iWriteOffset = 0;
-                }
-                char *pBlock = lBlocks.last();
-                Bu::size iCopy = iBlockSize-iWriteOffset;
-                if( iLeft < iCopy )
-                        iCopy = iLeft;
-                memcpy( pBlock+iWriteOffset, pBuf, iCopy );
-                iWriteOffset += iCopy;
-                iLeft -= iCopy;
-                pBuf += iCopy;
-                iTotalSize += iCopy;
-//              sio << "Wrote " << iCopy << " bytes, new size: " << iTotalSize
-//                      << sio.nl;
-        }
-
-        return nBytes;
+    if( nBytes <= 0 )
+        return 0;
+
+    if( lBlocks.isEmpty() )
+    {
+        addBlock();
+        iWriteOffset = 0;
+    }
+    Bu::size iLeft = nBytes;
+    const char *pBuf = (const char *)pRawBuf;
+
+    while( iLeft > 0 )
+    {
+        if( iWriteOffset == iBlockSize )
+        {
+            addBlock();
+            iWriteOffset = 0;
+        }
+        char *pBlock = lBlocks.last();
+        Bu::size iCopy = iBlockSize-iWriteOffset;
+        if( iLeft < iCopy )
+            iCopy = iLeft;
+        memcpy( pBlock+iWriteOffset, pBuf, iCopy );
+        iWriteOffset += iCopy;
+        iLeft -= iCopy;
+        pBuf += iCopy;
+        iTotalSize += iCopy;
+//      sio << "Wrote " << iCopy << " bytes, new size: " << iTotalSize
+//          << sio.nl;
+    }
+
+    return nBytes;
 }
 
 Bu::size Bu::QueueBuf::tell()
 {
-        return -1;
+    return -1;
 }
 
 void Bu::QueueBuf::seek( Bu::size iAmnt )
 {
-        if( iAmnt <= 0 )
-                return;
-
-        if( (Bu::size)iAmnt >= iTotalSize )
-        {
-//              sio << "seek: clear all data (" << iAmnt << ">=" << iTotalSize
-//                      << ")." << sio.nl;
-                close();
-                return;
-        }
-
-        iReadOffset += iAmnt;
-        iTotalSize -= iAmnt;
-        while( iReadOffset >= iBlockSize )
-        {
-                removeBlock();
-                iReadOffset -= iBlockSize;
-//              sio << "seek: removal step (" << iReadOffset << ")" << sio.nl;
-        }
+    if( iAmnt <= 0 )
+        return;
+
+    if( (Bu::size)iAmnt >= iTotalSize )
+    {
+//      sio << "seek: clear all data (" << iAmnt << ">=" << iTotalSize
+//          << ")." << sio.nl;
+        close();
+        return;
+    }
+
+    iReadOffset += iAmnt;
+    iTotalSize -= iAmnt;
+    while( iReadOffset >= iBlockSize )
+    {
+        removeBlock();
+        iReadOffset -= iBlockSize;
+//      sio << "seek: removal step (" << iReadOffset << ")" << sio.nl;
+    }
 }
 
 void Bu::QueueBuf::setPos( Bu::size )
@@ -198,12 +198,12 @@ void Bu::QueueBuf::setPosEnd( Bu::size )
 
 bool Bu::QueueBuf::isEos()
 {
-        return iTotalSize == 0;
+    return iTotalSize == 0;
 }
 
 bool Bu::QueueBuf::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::QueueBuf::flush()
@@ -212,32 +212,32 @@ void Bu::QueueBuf::flush()
 
 bool Bu::QueueBuf::canRead()
 {
-        return iTotalSize > 0;
+    return iTotalSize > 0;
 }
 
 bool Bu::QueueBuf::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::QueueBuf::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::QueueBuf::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::QueueBuf::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::QueueBuf::isBlocking()
 {
-        return false;
+    return false;
 }
 
 void Bu::QueueBuf::setBlocking( bool )
@@ -250,29 +250,29 @@ void Bu::QueueBuf::setSize( Bu::size )
 
 Bu::size Bu::QueueBuf::getSize() const
 {
-        return iTotalSize;
+    return iTotalSize;
 }
 
 Bu::size Bu::QueueBuf::getBlockSize() const
 {
-        return iBlockSize;
+    return iBlockSize;
 }
 
 Bu::String Bu::QueueBuf::getLocation() const
 {
-        return "";
+    return "";
 }
 
 void Bu::QueueBuf::addBlock()
 {
-        lBlocks.append( new char[iBlockSize] );
-//      sio << "Added new block." << sio.nl;
+    lBlocks.append( new char[iBlockSize] );
+//  sio << "Added new block." << sio.nl;
 }
 
 void Bu::QueueBuf::removeBlock()
 {
-        delete[] lBlocks.first();
-        lBlocks.erase( lBlocks.begin() );
-//      sio << "Removed block." << sio.nl;
+    delete[] lBlocks.first();
+    lBlocks.erase( lBlocks.begin() );
+//  sio << "Removed block." << sio.nl;
 }
 
diff --git a/src/stable/queuebuf.h b/src/stable/queuebuf.h
index 6e2a075..60aa115 100644
--- a/src/stable/queuebuf.h
+++ b/src/stable/queuebuf.h
@@ -12,55 +12,55 @@
 
 namespace Bu
 {
-        /**
-         * A queuing buffer stream class.  All data written to this class is
-         * appended to it, there is no stored position.  All data read is read
-         * from the begining and then thrown away.  It operates by using a linked
-         * list of small buffers, and deallocating or reusing them when it can.
-         */
-        class QueueBuf : public Bu::Stream
-        {
-        public:
-                QueueBuf( int iBlockSize=256 );
-                virtual ~QueueBuf();
+    /**
+     * A queuing buffer stream class.  All data written to this class is
+     * appended to it, there is no stored position.  All data read is read
+     * from the begining and then thrown away.  It operates by using a linked
+     * list of small buffers, and deallocating or reusing them when it can.
+     */
+    class QueueBuf : public Bu::Stream
+    {
+    public:
+        QueueBuf( int iBlockSize=256 );
+        virtual ~QueueBuf();
 
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size peek( void *pBuf, Bu::size nBytes );
-                virtual Bu::size peek( void *pBuf, Bu::size nBytes, Bu::size nSkip );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size peek( void *pBuf, Bu::size nBytes );
+        virtual Bu::size peek( void *pBuf, Bu::size nBytes, Bu::size nSkip );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
 
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-        private:
-                void addBlock();
-                void removeBlock();
+    private:
+        void addBlock();
+        void removeBlock();
 
-        private:
-                int iBlockSize;
-                int iReadOffset;
-                int iWriteOffset;
-                Bu::size iTotalSize;
-                typedef Bu::List<char *> BlockList;
-                BlockList lBlocks;
-        };
+    private:
+        int iBlockSize;
+        int iReadOffset;
+        int iWriteOffset;
+        Bu::size iTotalSize;
+        typedef Bu::List<char *> BlockList;
+        BlockList lBlocks;
+    };
 };
 
 #endif
diff --git a/src/stable/random.cpp b/src/stable/random.cpp
index 63416bf..6dca782 100644
--- a/src/stable/random.cpp
+++ b/src/stable/random.cpp
@@ -9,39 +9,39 @@
 #include "bu/randombasic.h"
 
 Bu::Random::Random() :
-        pGen( NULL )
+    pGen( NULL )
 {
-        pGen = new RandomBasic();
+    pGen = new RandomBasic();
 }
 
 Bu::Random::~Random()
 {
-        delete pGen;
-        pGen = NULL;
+    delete pGen;
+    pGen = NULL;
 }
 
 void Bu::Random::seed( int32_t iSeed )
 {
-        getInstance().pGen->seed( iSeed );
+    getInstance().pGen->seed( iSeed );
 }
 
 int32_t Bu::Random::rand()
 {
-        return getInstance().pGen->rand();
+    return getInstance().pGen->rand();
 }
 
 int32_t Bu::Random::rand( int32_t iMax )
 {
-        return getInstance().pGen->rand( iMax );
+    return getInstance().pGen->rand( iMax );
 }
 
 int32_t Bu::Random::rand( int32_t iMin, int32_t iMax )
 {
-        return getInstance().pGen->rand( iMin, iMax );
+    return getInstance().pGen->rand( iMin, iMax );
 }
 
 double Bu::Random::randNorm()
 {
-        return getInstance().pGen->randNorm();
+    return getInstance().pGen->randNorm();
 }
 
diff --git a/src/stable/random.h b/src/stable/random.h
index 43b8917..7989188 100644
--- a/src/stable/random.h
+++ b/src/stable/random.h
@@ -12,50 +12,50 @@
 
 namespace Bu
 {
-        class RandomBase;
-        class Random : public Bu::Singleton<Bu::Random>
-        {
-        friend class Bu::Singleton<Bu::Random>;
-        private:
-                Random();
-                virtual ~Random();
-
-        public:
-                template<typename cl>
-                static void setGenerator()
-                {
-                        delete getInstance().pGen;
-                        getInstance().pGen = new cl();
-                }
-                
-                template<typename cl, typename t1>
-                static void setGenerator( t1 p1 )
-                {
-                        delete getInstance().pGen;
-                        getInstance().pGen = new cl( p1 );
-                }
-                
-                template<typename cl, typename t1, typename t2>
-                static void setGenerator( t1 p1, t2 p2 )
-                {
-                        delete getInstance().pGen;
-                        getInstance().pGen = new cl( p1, p2 );
-                }
-                
-                RandomBase &getGenerator() { return *pGen; }
-
-                static void seed( int32_t iSeed );
-                static int32_t rand();
-                static int32_t rand( int32_t iMax );
-                static int32_t rand( int32_t iMin, int32_t iMax );
-                static double randNorm();
-
-        private:
-                void checkInit();
-
-        private:
-                Bu::RandomBase *pGen;
-        };
+    class RandomBase;
+    class Random : public Bu::Singleton<Bu::Random>
+    {
+    friend class Bu::Singleton<Bu::Random>;
+    private:
+        Random();
+        virtual ~Random();
+
+    public:
+        template<typename cl>
+        static void setGenerator()
+        {
+            delete getInstance().pGen;
+            getInstance().pGen = new cl();
+        }
+        
+        template<typename cl, typename t1>
+        static void setGenerator( t1 p1 )
+        {
+            delete getInstance().pGen;
+            getInstance().pGen = new cl( p1 );
+        }
+        
+        template<typename cl, typename t1, typename t2>
+        static void setGenerator( t1 p1, t2 p2 )
+        {
+            delete getInstance().pGen;
+            getInstance().pGen = new cl( p1, p2 );
+        }
+        
+        RandomBase &getGenerator() { return *pGen; }
+
+        static void seed( int32_t iSeed );
+        static int32_t rand();
+        static int32_t rand( int32_t iMax );
+        static int32_t rand( int32_t iMin, int32_t iMax );
+        static double randNorm();
+
+    private:
+        void checkInit();
+
+    private:
+        Bu::RandomBase *pGen;
+    };
 };
 
 #endif
diff --git a/src/stable/randombase.h b/src/stable/randombase.h
index d33bb99..946284f 100644
--- a/src/stable/randombase.h
+++ b/src/stable/randombase.h
@@ -11,25 +11,25 @@
 
 namespace Bu
 {
-        class RandomBase
-        {
-        public:
-                RandomBase();
-                virtual ~RandomBase();
+    class RandomBase
+    {
+    public:
+        RandomBase();
+        virtual ~RandomBase();
 
-                virtual void seed( int32_t iSeed )=0;
-                virtual int32_t rand()=0;
-                virtual inline int32_t rand( int32_t iMax ) {
-                        return rand( 0, iMax );
-                }
-                virtual inline int32_t rand( int32_t iMin, int32_t iMax ) {
-                        return iMin+(randNorm()*(iMax-iMin));
-                }
-                virtual inline double randNorm() {
-                        return (((uint32_t)rand())&0xfffffffeul)*0x1.00000001p-32;
-//                      return (((uint32_t)rand())&0xfffffffeul)/(double)(0xfffffffful);
-                }
-        };
+        virtual void seed( int32_t iSeed )=0;
+        virtual int32_t rand()=0;
+        virtual inline int32_t rand( int32_t iMax ) {
+            return rand( 0, iMax );
+        }
+        virtual inline int32_t rand( int32_t iMin, int32_t iMax ) {
+            return iMin+(randNorm()*(iMax-iMin));
+        }
+        virtual inline double randNorm() {
+            return (((uint32_t)rand())&0xfffffffeul)*0x1.00000001p-32;
+//          return (((uint32_t)rand())&0xfffffffeul)/(double)(0xfffffffful);
+        }
+    };
 };
 
 #endif
diff --git a/src/stable/randombasic.cpp b/src/stable/randombasic.cpp
index 89e2780..e253b70 100644
--- a/src/stable/randombasic.cpp
+++ b/src/stable/randombasic.cpp
@@ -8,9 +8,9 @@
 #include "bu/randombasic.h"
 
 Bu::RandomBasic::RandomBasic() :
-        a( 6364136223846793005ll ),
-        c( 1442695040888963407ll ),
-        x( 0 )
+    a( 6364136223846793005ll ),
+    c( 1442695040888963407ll ),
+    x( 0 )
 {
 }
 
@@ -20,12 +20,12 @@ Bu::RandomBasic::~RandomBasic()
 
 void Bu::RandomBasic::seed( int32_t iSeed )
 {
-        c = iSeed;
+    c = iSeed;
 }
 
 int32_t Bu::RandomBasic::rand()
 {
-        x = (a*x + c);
-        return (int32_t)x;
+    x = (a*x + c);
+    return (int32_t)x;
 }
 
diff --git a/src/stable/randombasic.h b/src/stable/randombasic.h
index a53e16f..4d1c2f8 100644
--- a/src/stable/randombasic.h
+++ b/src/stable/randombasic.h
@@ -11,19 +11,19 @@
 
 namespace Bu
 {
-        class RandomBasic : public RandomBase
-        {
-        public:
-                RandomBasic();
-                virtual ~RandomBasic();
+    class RandomBasic : public RandomBase
+    {
+    public:
+        RandomBasic();
+        virtual ~RandomBasic();
 
-                virtual void seed( int32_t iSeed );
+        virtual void seed( int32_t iSeed );
 
-                virtual int32_t rand();
+        virtual int32_t rand();
 
-        private:
-                int64_t a, c, x;
-        };
+    private:
+        int64_t a, c, x;
+    };
 };
 
 #endif
diff --git a/src/stable/randomcmwc.cpp b/src/stable/randomcmwc.cpp
index 9f68982..1d4a913 100644
--- a/src/stable/randomcmwc.cpp
+++ b/src/stable/randomcmwc.cpp
@@ -12,52 +12,52 @@
 #define PHI 0x9e3779b9
 
 Bu::RandomCmwc::RandomCmwc() :
-        q( 0 ),
-        c( 362436 )
+    q( 0 ),
+    c( 362436 )
 {
-        q = new uint32_t[4096];
+    q = new uint32_t[4096];
 }
 
 Bu::RandomCmwc::~RandomCmwc()
 {
-        delete[] q;
+    delete[] q;
 }
 
 void Bu::RandomCmwc::seed( int32_t iSeed )
 {
-        i = 4095;
-        c = 362436;
+    i = 4095;
+    c = 362436;
 
-        Bu::RandomBasic rb;
-        rb.seed( iSeed );
+    Bu::RandomBasic rb;
+    rb.seed( iSeed );
 
-        for( int j = 0; j < 4096; j++ )
-                q[j] = rb.rand();
+    for( int j = 0; j < 4096; j++ )
+        q[j] = rb.rand();
 
-        c = rb.rand();
+    c = rb.rand();
 
-        return;
-        q[0] = (uint32_t)rb.rand();
-        q[1] = (uint32_t)rb.rand() + PHI;
-        q[2] = (uint32_t)rb.rand() + PHI + PHI;
+    return;
+    q[0] = (uint32_t)rb.rand();
+    q[1] = (uint32_t)rb.rand() + PHI;
+    q[2] = (uint32_t)rb.rand() + PHI + PHI;
 
-        for (int j = 3; j < 4096; j++)
-                q[j] = q[j - 3] ^ q[j - 2] ^ PHI ^ j;
+    for (int j = 3; j < 4096; j++)
+        q[j] = q[j - 3] ^ q[j - 2] ^ PHI ^ j;
 }
 
 int32_t Bu::RandomCmwc::rand()
 {
-        uint64_t t, a = 18782LL;
-        uint32_t x, r = 0xfffffffe;
-        i = (i + 1) & 4095;
-        t = a * q[i] + c;
-        c = (t >> 32);
-        x = t + c;
-        if( x < c )
-        {
-                x++;
-                c++;
-        }
-        return (q[i] = r - x);
+    uint64_t t, a = 18782LL;
+    uint32_t x, r = 0xfffffffe;
+    i = (i + 1) & 4095;
+    t = a * q[i] + c;
+    c = (t >> 32);
+    x = t + c;
+    if( x < c )
+    {
+        x++;
+        c++;
+    }
+    return (q[i] = r - x);
 }
 
diff --git a/src/stable/randomcmwc.h b/src/stable/randomcmwc.h
index fff891b..547b5bb 100644
--- a/src/stable/randomcmwc.h
+++ b/src/stable/randomcmwc.h
@@ -11,19 +11,19 @@
 
 namespace Bu
 {
-        class RandomCmwc : public RandomBase
-        {
-        public:
-                RandomCmwc();
-                virtual ~RandomCmwc();
+    class RandomCmwc : public RandomBase
+    {
+    public:
+        RandomCmwc();
+        virtual ~RandomCmwc();
 
-                virtual void seed( int32_t iSeed );
+        virtual void seed( int32_t iSeed );
 
-                virtual int32_t rand();
+        virtual int32_t rand();
 
-        private:
-                uint32_t *q, c, i;
-        };
+    private:
+        uint32_t *q, c, i;
+    };
 };
 
 #endif
diff --git a/src/stable/randomsystem.cpp b/src/stable/randomsystem.cpp
index 0501587..68c69d5 100644
--- a/src/stable/randomsystem.cpp
+++ b/src/stable/randomsystem.cpp
@@ -2,39 +2,39 @@
 #include "bu/file.h"
 
 Bu::RandomSystem::RandomSystem( Type eType ) :
-        eType( eType ),
-        pSrc( 0 )
+    eType( eType ),
+    pSrc( 0 )
 {
-        switch( eType )
-        {
-                case Bu::RandomSystem::Fast:
-                        pSrc = new Bu::File("/dev/urandom", Bu::File::Read );
-                        break;
+    switch( eType )
+    {
+        case Bu::RandomSystem::Fast:
+            pSrc = new Bu::File("/dev/urandom", Bu::File::Read );
+            break;
 
-                case Bu::RandomSystem::Good:
-                        pSrc = new Bu::File("/dev/random", Bu::File::Read );
-                        break;
-        }
+        case Bu::RandomSystem::Good:
+            pSrc = new Bu::File("/dev/random", Bu::File::Read );
+            break;
+    }
 }
 
 Bu::RandomSystem::~RandomSystem()
 {
-        delete pSrc;
+    delete pSrc;
 }
 
 void Bu::RandomSystem::seed( int32_t /*iSeed*/ )
 {
-        // Seed really has no effect here...
-        // on linux, if we were root, we could write data to random/urandom to
-        // perturb the data, but it's not necesarry
+    // Seed really has no effect here...
+    // on linux, if we were root, we could write data to random/urandom to
+    // perturb the data, but it's not necesarry
 }
 
 int32_t Bu::RandomSystem::rand()
 {
-        if( !pSrc )
-                throw Bu::ExceptionBase("Not initialized");
-        int32_t i;
-        pSrc->read( &i, sizeof(int32_t) );
-        return i;
+    if( !pSrc )
+        throw Bu::ExceptionBase("Not initialized");
+    int32_t i;
+    pSrc->read( &i, sizeof(int32_t) );
+    return i;
 }
 
diff --git a/src/stable/randomsystem.h b/src/stable/randomsystem.h
index 7106d58..63b40f3 100644
--- a/src/stable/randomsystem.h
+++ b/src/stable/randomsystem.h
@@ -11,27 +11,27 @@
 
 namespace Bu
 {
-        class File;
-        class RandomSystem : public RandomBase
-        {
-        public:
-                enum Type
-                {
-                        Fast,
-                        Good
-                };
+    class File;
+    class RandomSystem : public RandomBase
+    {
+    public:
+        enum Type
+        {
+            Fast,
+            Good
+        };
 
-                RandomSystem( Type eType=Fast );
-                virtual ~RandomSystem();
+        RandomSystem( Type eType=Fast );
+        virtual ~RandomSystem();
 
-                virtual void seed( int32_t iSeed );
+        virtual void seed( int32_t iSeed );
 
-                virtual int32_t rand();
+        virtual int32_t rand();
 
-        private:
-                Type eType;
-                File *pSrc;
-        };
+    private:
+        Type eType;
+        File *pSrc;
+    };
 };
 
 #endif
diff --git a/src/stable/ringbuffer.h b/src/stable/ringbuffer.h
index 79c5a15..39d053e 100644
--- a/src/stable/ringbuffer.h
+++ b/src/stable/ringbuffer.h
@@ -15,237 +15,237 @@
 
 namespace Bu
 {
-        template<typename value, typename valuealloc> class RingBuffer;
-
-        /** @cond DEVEL */
-        template<typename value, typename valuealloc>
-        class RingBufferCore
-        {
-        friend class RingBuffer<value, valuealloc>;
-        friend class SharedCore<RingBuffer<value, valuealloc>,
-                   RingBufferCore<value, valuealloc> >;
-        private:
-                RingBufferCore() :
-                        iCapacity( 0 ),
-                        iStart( -1 ),
-                        iEnd( -2 ),
-                        aData( NULL )
-                {
-                }
-
-                virtual ~RingBufferCore()
-                {
-                        clear();
-                }
-
-                void init( int iNewCapacity )
-                {
-                        if( iCapacity > 0 )
-                                return;
-
-                        iCapacity = iNewCapacity;
-                        iStart = -1;
-                        iEnd = -2;
-                        aData = va.allocate( iCapacity );
-                }
-
-                void clear()
-                {
-                        for( int j = iStart; j < iEnd; j=(j+1%iCapacity) )
-                        {
-                                va.destroy( &aData[j] );
-                        }
-                        va.deallocate( aData, iCapacity );
-                        aData = NULL;
-                        iCapacity = 0;
-                }
-                
-                void enqueue( const value &v )
-                {
-                        if( iStart == -1 )
-                        {
-                                iStart = 0;
-                                iEnd = 1;
-                                va.construct( &aData[0], v );
-                                return;
-                        }
-                        else if( iStart == iEnd )
-                        {
-                                // The ringbuffer is full
-                                dequeue();
-                        }
-                        va.construct( &aData[iEnd], v );
-                        iEnd = (iEnd+1)%iCapacity;
-                }
-
-                value dequeue()
-                {
-                        if( iStart == -1 )
-                        {
-                                throw ExceptionBase("No data");
-                        }
-                        else
-                        {
-                                value &v = aData[iStart];
-                                va.destroy( &aData[iStart] );
-                                iStart = (iStart+1)%iCapacity;
-                                if( iStart == iEnd )
-                                {
-                                        iStart = -1;
-                                        iEnd = -2;
-                                }
-                                return v;
-                        }
-                }
-
-                value &get( int iIndex )
-                {
-                        return aData[(iIndex+iStart)%iCapacity];
-                }
-
-                value &first()
-                {
-                        return aData[iStart];
-                }
-
-                value &last()
-                {
-                        return aData[(iEnd-1+iCapacity)%iCapacity];
-                }
-
-                int getSize()
-                {
-                        if( iStart < 0 )
-                                return 0;
-                        if( iEnd == iStart )
-                                return iCapacity;
-                        if( iEnd < iStart )
-                                return iEnd-iStart;
-                        return iCapacity-(iEnd-iStart);
-                }
-
-                int iCapacity;
-                int iStart, iEnd;
-                value *aData;
-                valuealloc va;
-        };
-        /** @endcond */
-
-        /**
-         *@ingroup Containers
-         */
-        template<typename value, typename valuealloc=std::allocator<value> >
-        class RingBuffer : public Queue<value>, public SharedCore<
-                                           RingBuffer<value, valuealloc>,
-                                           RingBufferCore<value, valuealloc>
-                                           >
-        {
-        private:
-                typedef RingBuffer<value, valuealloc> MyType;
-                typedef RingBufferCore<value, valuealloc> Core;
-
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_allocateCore;
-
-        public:
-                RingBuffer( int iCapacity )
-                {
-                        core->init( iCapacity );
-                }
-
-                RingBuffer( const RingBuffer &rSrc ) :
-                        SharedCore<MyType, Core>( rSrc )
-                {
-                }
-
-                virtual ~RingBuffer()
-                {
-                }
-
-                int getCapacity() const
-                {
-                        return core->iCapacity;
-                }
-
-                bool isFilled() const
-                {
-                        return (core->iStart == core->iEnd);
-                }
-
-                bool isEmpty() const
-                {
-                        return (core->iStart == -1);
-                }
-
-                virtual void enqueue( const value &v )
-                {
-                        _hardCopy();
-
-                        core->enqueue( v );
-                }
-
-                virtual value dequeue()
-                {
-                        _hardCopy();
-
-                        return core->dequeue();
-                }
-
-                virtual int getSize() const
-                {
-                        return core->getSize();
-                }
-
-                virtual value &peek()
-                {
-                        _hardCopy();
-
-                        return core->get( 0 );
-                }
-
-                virtual const value &peek() const
-                {
-                        return core->get( 0 );
-                }
-
-                virtual value &first()
-                {
-                        _hardCopy();
-
-                        return core->first();
-                }
-
-                virtual value &last()
-                {
-                        _hardCopy();
-
-                        return core->last();
-                }
-
-                value &operator[]( int iIndex )
-                {
-                        _hardCopy();
-
-                        return core->get( iIndex );
-                }
-
-        protected:
-                virtual Core *_copyCore( Core *src )
-                {
-                        Core *pRet = _allocateCore();
-
-                        pRet->init( src->iCapacity );
-                        int iSize = src->getSize();
-                        for( int j = 0; j < iSize; j++ )
-                        {
-                                pRet->enqueue( src->get( j ) );
-                        }
-
-                        return pRet;
-                }
-        };
+    template<typename value, typename valuealloc> class RingBuffer;
+
+    /** @cond DEVEL */
+    template<typename value, typename valuealloc>
+    class RingBufferCore
+    {
+    friend class RingBuffer<value, valuealloc>;
+    friend class SharedCore<RingBuffer<value, valuealloc>,
+           RingBufferCore<value, valuealloc> >;
+    private:
+        RingBufferCore() :
+            iCapacity( 0 ),
+            iStart( -1 ),
+            iEnd( -2 ),
+            aData( NULL )
+        {
+        }
+
+        virtual ~RingBufferCore()
+        {
+            clear();
+        }
+
+        void init( int iNewCapacity )
+        {
+            if( iCapacity > 0 )
+                return;
+
+            iCapacity = iNewCapacity;
+            iStart = -1;
+            iEnd = -2;
+            aData = va.allocate( iCapacity );
+        }
+
+        void clear()
+        {
+            for( int j = iStart; j < iEnd; j=(j+1%iCapacity) )
+            {
+                va.destroy( &aData[j] );
+            }
+            va.deallocate( aData, iCapacity );
+            aData = NULL;
+            iCapacity = 0;
+        }
+        
+        void enqueue( const value &v )
+        {
+            if( iStart == -1 )
+            {
+                iStart = 0;
+                iEnd = 1;
+                va.construct( &aData[0], v );
+                return;
+            }
+            else if( iStart == iEnd )
+            {
+                // The ringbuffer is full
+                dequeue();
+            }
+            va.construct( &aData[iEnd], v );
+            iEnd = (iEnd+1)%iCapacity;
+        }
+
+        value dequeue()
+        {
+            if( iStart == -1 )
+            {
+                throw ExceptionBase("No data");
+            }
+            else
+            {
+                value &v = aData[iStart];
+                va.destroy( &aData[iStart] );
+                iStart = (iStart+1)%iCapacity;
+                if( iStart == iEnd )
+                {
+                    iStart = -1;
+                    iEnd = -2;
+                }
+                return v;
+            }
+        }
+
+        value &get( int iIndex )
+        {
+            return aData[(iIndex+iStart)%iCapacity];
+        }
+
+        value &first()
+        {
+            return aData[iStart];
+        }
+
+        value &last()
+        {
+            return aData[(iEnd-1+iCapacity)%iCapacity];
+        }
+
+        int getSize()
+        {
+            if( iStart < 0 )
+                return 0;
+            if( iEnd == iStart )
+                return iCapacity;
+            if( iEnd < iStart )
+                return iEnd-iStart;
+            return iCapacity-(iEnd-iStart);
+        }
+
+        int iCapacity;
+        int iStart, iEnd;
+        value *aData;
+        valuealloc va;
+    };
+    /** @endcond */
+
+    /**
+     *@ingroup Containers
+     */
+    template<typename value, typename valuealloc=std::allocator<value> >
+    class RingBuffer : public Queue<value>, public SharedCore<
+                       RingBuffer<value, valuealloc>,
+                       RingBufferCore<value, valuealloc>
+                       >
+    {
+    private:
+        typedef RingBuffer<value, valuealloc> MyType;
+        typedef RingBufferCore<value, valuealloc> Core;
+
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_allocateCore;
+
+    public:
+        RingBuffer( int iCapacity )
+        {
+            core->init( iCapacity );
+        }
+
+        RingBuffer( const RingBuffer &rSrc ) :
+            SharedCore<MyType, Core>( rSrc )
+        {
+        }
+
+        virtual ~RingBuffer()
+        {
+        }
+
+        int getCapacity() const
+        {
+            return core->iCapacity;
+        }
+
+        bool isFilled() const
+        {
+            return (core->iStart == core->iEnd);
+        }
+
+        bool isEmpty() const
+        {
+            return (core->iStart == -1);
+        }
+
+        virtual void enqueue( const value &v )
+        {
+            _hardCopy();
+
+            core->enqueue( v );
+        }
+
+        virtual value dequeue()
+        {
+            _hardCopy();
+
+            return core->dequeue();
+        }
+
+        virtual int getSize() const
+        {
+            return core->getSize();
+        }
+
+        virtual value &peek()
+        {
+            _hardCopy();
+
+            return core->get( 0 );
+        }
+
+        virtual const value &peek() const
+        {
+            return core->get( 0 );
+        }
+
+        virtual value &first()
+        {
+            _hardCopy();
+
+            return core->first();
+        }
+
+        virtual value &last()
+        {
+            _hardCopy();
+
+            return core->last();
+        }
+
+        value &operator[]( int iIndex )
+        {
+            _hardCopy();
+
+            return core->get( iIndex );
+        }
+
+    protected:
+        virtual Core *_copyCore( Core *src )
+        {
+            Core *pRet = _allocateCore();
+
+            pRet->init( src->iCapacity );
+            int iSize = src->getSize();
+            for( int j = 0; j < iSize; j++ )
+            {
+                pRet->enqueue( src->get( j ) );
+            }
+
+            return pRet;
+        }
+    };
 }
 
 #endif
diff --git a/src/stable/server.cpp b/src/stable/server.cpp
index 39ff7bb..e6c256e 100644
--- a/src/stable/server.cpp
+++ b/src/stable/server.cpp
@@ -14,138 +14,138 @@
 #include "bu/config.h"
 
 Bu::Server::Server() :
-        nTimeoutSec( 0 ),
-        nTimeoutUSec( 0 ),
-        bAutoTick( false )
+    nTimeoutSec( 0 ),
+    nTimeoutUSec( 0 ),
+    bAutoTick( false )
 {
-        FD_ZERO( &fdActive );
+    FD_ZERO( &fdActive );
 }
 
 Bu::Server::~Server()
 {
-        shutdown();
+    shutdown();
 }
 
 void Bu::Server::addPort( int nPort, int nPoolSize )
 {
-        TcpServerSocket *s = new TcpServerSocket( nPort, nPoolSize );
-        socket_t nSocket = s->getSocket();
-        FD_SET( nSocket, &fdActive );
-        hServers.insert( nSocket, s );
+    TcpServerSocket *s = new TcpServerSocket( nPort, nPoolSize );
+    socket_t nSocket = s->getSocket();
+    FD_SET( nSocket, &fdActive );
+    hServers.insert( nSocket, s );
 }
 
 void Bu::Server::addPort( const String &sAddr, int nPort, int nPoolSize )
 {
-        TcpServerSocket *s = new TcpServerSocket( sAddr, nPort, nPoolSize );
-        socket_t nSocket = s->getSocket();
-        FD_SET( nSocket, &fdActive );
-        hServers.insert( nSocket, s );
+    TcpServerSocket *s = new TcpServerSocket( sAddr, nPort, nPoolSize );
+    socket_t nSocket = s->getSocket();
+    FD_SET( nSocket, &fdActive );
+    hServers.insert( nSocket, s );
 }
 
 void Bu::Server::setTimeout( int nTimeoutSec, int nTimeoutUSec )
 {
-        this->nTimeoutSec = nTimeoutSec;
-        this->nTimeoutUSec = nTimeoutUSec;
+    this->nTimeoutSec = nTimeoutSec;
+    this->nTimeoutUSec = nTimeoutUSec;
 }
 
 void Bu::Server::scan()
 {
-        struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
-        
-        fd_set fdRead = fdActive;
-        fd_set fdWrite /* = fdActive*/;
-        fd_set fdException = fdActive;
-
-        FD_ZERO( &fdWrite );
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                if( (*i)->hasOutput() )
-                        FD_SET( i.getKey(), &fdWrite );
-        }
-
-        if( TEMP_FAILURE_RETRY( select( FD_SETSIZE,
-                        &fdRead, &fdWrite, &fdException, &xTimeout ) ) < 0 )
-        {
-                throw ExceptionBase("Error attempting to scan open connections.");
-        }
-
-        for( int j = 0; j < FD_SETSIZE; j++ )
-        {
-                if( FD_ISSET( j, &fdRead ) )
-                {
-                        if( hServers.has( j ) )
-                        {
-                                TcpServerSocket *pSrv = hServers.get( j );
-                                addClient( pSrv->accept(), pSrv->getPort() );
-                        }
-                        else
-                        {
-                                Client *pClient = hClients.get( j );
-                                pClient->processInput();
-                                if( !pClient->isOpen() )
-                                {
-                                        closeClient( j );
-                                }
-                        }
-                }
-                if( FD_ISSET( j, &fdWrite ) )
-                {
-                        try
-                        {
-                                Client *pClient = hClients.get( j );
-                                try
-                                {
-                                        pClient->processOutput();
-                                }
-                                catch( Bu::TcpSocketException &e )
-                                {
-                                        closeClient( j );
-                                }
-                        }
-                        catch( Bu::HashException &e )
-                        {
-                                // Do nothing, I guess, the client is already dead...
-                                // TODO:  Someday, we may want to handle this more graceully.
-                        }
-                }
-        }
-
-        Bu::List<int> lDelete;
-        // Now we just try to write all the pending data on all the sockets.
-        // this could be done better eventually, if we care about the socket
-        // wanting to accept writes (using a select).
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                if( (*i)->wantsDisconnect() && !(*i)->hasOutput() )
-                {
-                        lDelete.append( i.getKey() );
-                }
-        }
-
-        for( Bu::List<int>::iterator i = lDelete.begin(); i != lDelete.end(); i++ )
-        {
-                closeClient( *i );
-        }
-
-        if( bAutoTick )
-                tick();
+    struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
+    
+    fd_set fdRead = fdActive;
+    fd_set fdWrite /* = fdActive*/;
+    fd_set fdException = fdActive;
+
+    FD_ZERO( &fdWrite );
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        if( (*i)->hasOutput() )
+            FD_SET( i.getKey(), &fdWrite );
+    }
+
+    if( TEMP_FAILURE_RETRY( select( FD_SETSIZE,
+            &fdRead, &fdWrite, &fdException, &xTimeout ) ) < 0 )
+    {
+        throw ExceptionBase("Error attempting to scan open connections.");
+    }
+
+    for( int j = 0; j < FD_SETSIZE; j++ )
+    {
+        if( FD_ISSET( j, &fdRead ) )
+        {
+            if( hServers.has( j ) )
+            {
+                TcpServerSocket *pSrv = hServers.get( j );
+                addClient( pSrv->accept(), pSrv->getPort() );
+            }
+            else
+            {
+                Client *pClient = hClients.get( j );
+                pClient->processInput();
+                if( !pClient->isOpen() )
+                {
+                    closeClient( j );
+                }
+            }
+        }
+        if( FD_ISSET( j, &fdWrite ) )
+        {
+            try
+            {
+                Client *pClient = hClients.get( j );
+                try
+                {
+                    pClient->processOutput();
+                }
+                catch( Bu::TcpSocketException &e )
+                {
+                    closeClient( j );
+                }
+            }
+            catch( Bu::HashException &e )
+            {
+                // Do nothing, I guess, the client is already dead...
+                // TODO:  Someday, we may want to handle this more graceully.
+            }
+        }
+    }
+
+    Bu::List<int> lDelete;
+    // Now we just try to write all the pending data on all the sockets.
+    // this could be done better eventually, if we care about the socket
+    // wanting to accept writes (using a select).
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        if( (*i)->wantsDisconnect() && !(*i)->hasOutput() )
+        {
+            lDelete.append( i.getKey() );
+        }
+    }
+
+    for( Bu::List<int>::iterator i = lDelete.begin(); i != lDelete.end(); i++ )
+    {
+        closeClient( *i );
+    }
+
+    if( bAutoTick )
+        tick();
 }
 
 void Bu::Server::addClient( socket_t nSocket, int nPort )
 {
-        FD_SET( nSocket, &fdActive );
+    FD_SET( nSocket, &fdActive );
 
-        Client *c = new Client(
-                new Bu::TcpSocket( nSocket ),
-                new SrvClientLinkFactory()
-                );
-        hClients.insert( nSocket, c );
+    Client *c = new Client(
+        new Bu::TcpSocket( nSocket ),
+        new SrvClientLinkFactory()
+        );
+    hClients.insert( nSocket, c );
 
-        onNewConnection( c, nPort );
+    onNewConnection( c, nPort );
 }
 
 Bu::Server::SrvClientLink::SrvClientLink( Bu::Client *pClient ) :
-        pClient( pClient )
+    pClient( pClient )
 {
 }
 
@@ -155,7 +155,7 @@ Bu::Server::SrvClientLink::~SrvClientLink()
 
 void Bu::Server::SrvClientLink::sendMessage( const Bu::String &sMsg )
 {
-        pClient->onMessage( sMsg );
+    pClient->onMessage( sMsg );
 }
 
 Bu::Server::SrvClientLinkFactory::SrvClientLinkFactory()
@@ -167,48 +167,48 @@ Bu::Server::SrvClientLinkFactory::~SrvClientLinkFactory()
 }
 
 Bu::ClientLink *Bu::Server::SrvClientLinkFactory::createLink(
-                Bu::Client *pClient )
+        Bu::Client *pClient )
 {
-        return new SrvClientLink( pClient );
+    return new SrvClientLink( pClient );
 }
 
 void Bu::Server::setAutoTick( bool bEnable )
 {
-        bAutoTick = bEnable;
+    bAutoTick = bEnable;
 }
 
 void Bu::Server::tick()
 {
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                (*i)->tick();
-        }
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        (*i)->tick();
+    }
 }
 
 void Bu::Server::shutdown()
 {
-        for( SrvHash::iterator i = hServers.begin(); i != hServers.end(); i++ )
-        {
-                delete *i;
-        }
+    for( SrvHash::iterator i = hServers.begin(); i != hServers.end(); i++ )
+    {
+        delete *i;
+    }
 
-        hServers.clear();
+    hServers.clear();
 
-        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
-        {
-                closeClient( i.getKey() );
-        }
+    for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+    {
+        closeClient( i.getKey() );
+    }
 
-        hClients.clear();
+    hClients.clear();
 }
 
 void Bu::Server::closeClient( socket_t iSocket )
 {
-        Bu::Client *pClient = hClients.get( iSocket );
-        onClosedConnection( pClient );
-        pClient->close();
-        hClients.erase( iSocket );
-        FD_CLR( iSocket, &fdActive );
-        delete pClient;
+    Bu::Client *pClient = hClients.get( iSocket );
+    onClosedConnection( pClient );
+    pClient->close();
+    hClients.erase( iSocket );
+    FD_CLR( iSocket, &fdActive );
+    delete pClient;
 }
 
diff --git a/src/stable/server.h b/src/stable/server.h
index 5a414d9..05ec018 100644
--- a/src/stable/server.h
+++ b/src/stable/server.h
@@ -11,7 +11,7 @@
 #include <stdint.h>
 
 #ifndef WIN32
-        #include <sys/select.h>
+    #include <sys/select.h>
 #endif
 
 #include "bu/string.h"
@@ -25,90 +25,90 @@
 
 namespace Bu
 {
-        class TcpServerSocket;
-        class TcpSocket;
-        class Client;
-
-        /**
-         * Core of a network server.  This class is distinct from a ServerSocket in
-         * that a ServerSocket is one listening socket, nothing more.  Socket will
-         * manage a pool of both ServerSockets and connected Sockets along with
-         * their protocols and buffers.
-         *
-         * To start serving on a new port, use the addPort functions.  Each call to
-         * addPort creates a new ServerSocket, starts it listening, and adds it to
-         * the server pool.
-         *
-         * All of the real work is done by scan, which will wait for up
-         * to the timeout set by setTimeout before returning if there is no data
-         * pending.  scan should probably be called in some sort of tight
-         * loop, possibly in it's own thread, or in the main control loop.
-         *
-         * In order to use a Server you must subclass it and implement the pure
-         * virtual functions.  These allow you to receive notification of events
-         * happening within the server itself, and actually makes it useful.
-         *@ingroup Serving
-         */
-        class Server
-        {
-        public:
-                Server();
-                virtual ~Server();
+    class TcpServerSocket;
+    class TcpSocket;
+    class Client;
+
+    /**
+     * Core of a network server.  This class is distinct from a ServerSocket in
+     * that a ServerSocket is one listening socket, nothing more.  Socket will
+     * manage a pool of both ServerSockets and connected Sockets along with
+     * their protocols and buffers.
+     *
+     * To start serving on a new port, use the addPort functions.  Each call to
+     * addPort creates a new ServerSocket, starts it listening, and adds it to
+     * the server pool.
+     *
+     * All of the real work is done by scan, which will wait for up
+     * to the timeout set by setTimeout before returning if there is no data
+     * pending.  scan should probably be called in some sort of tight
+     * loop, possibly in it's own thread, or in the main control loop.
+     *
+     * In order to use a Server you must subclass it and implement the pure
+     * virtual functions.  These allow you to receive notification of events
+     * happening within the server itself, and actually makes it useful.
+     *@ingroup Serving
+     */
+    class Server
+    {
+    public:
+        Server();
+        virtual ~Server();
 
 #ifdef WIN32
-                typedef unsigned int socket_t;
+        typedef unsigned int socket_t;
 #else
-                typedef int socket_t;
+        typedef int socket_t;
 #endif
 
-                void addPort( int nPort, int nPoolSize=40 );
-                void addPort( const String &sAddr, int nPort, int nPoolSize=40 );
+        void addPort( int nPort, int nPoolSize=40 );
+        void addPort( const String &sAddr, int nPort, int nPoolSize=40 );
 
-                virtual void scan();
-                void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
+        virtual void scan();
+        void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
 
-                void addClient( socket_t nSocket, int nPort );
+        void addClient( socket_t nSocket, int nPort );
 
-                void setAutoTick( bool bEnable=true );
-                void tick();
+        void setAutoTick( bool bEnable=true );
+        void tick();
 
-                virtual void onNewConnection( Client *pClient, int nPort )=0;
-                virtual void onClosedConnection( Client *pClient )=0;
+        virtual void onNewConnection( Client *pClient, int nPort )=0;
+        virtual void onClosedConnection( Client *pClient )=0;
 
-                void shutdown();
+        void shutdown();
 
-        private:
-                void closeClient( socket_t iSocket );
-                class SrvClientLink : public Bu::ClientLink
-                {
-                public:
-                        SrvClientLink( Bu::Client *pClient );
-                        virtual ~SrvClientLink();
+    private:
+        void closeClient( socket_t iSocket );
+        class SrvClientLink : public Bu::ClientLink
+        {
+        public:
+            SrvClientLink( Bu::Client *pClient );
+            virtual ~SrvClientLink();
 
-                        virtual void sendMessage( const Bu::String &sMsg );
+            virtual void sendMessage( const Bu::String &sMsg );
 
-                private:
-                        Bu::Client *pClient;
-                };
+        private:
+            Bu::Client *pClient;
+        };
 
-                class SrvClientLinkFactory : public Bu::ClientLinkFactory
-                {
-                public:
-                        SrvClientLinkFactory();
-                        virtual ~SrvClientLinkFactory();
+        class SrvClientLinkFactory : public Bu::ClientLinkFactory
+        {
+        public:
+            SrvClientLinkFactory();
+            virtual ~SrvClientLinkFactory();
 
-                        virtual Bu::ClientLink *createLink( Bu::Client *pClient );
-                };
+            virtual Bu::ClientLink *createLink( Bu::Client *pClient );
+        };
 
-                int nTimeoutSec;
-                int nTimeoutUSec;
-                fd_set fdActive;
-                typedef Hash<socket_t,TcpServerSocket *> SrvHash;
-                SrvHash hServers;
-                typedef Hash<socket_t,Client *> ClientHash;
-                ClientHash hClients;
-                bool bAutoTick;
-        };
+        int nTimeoutSec;
+        int nTimeoutUSec;
+        fd_set fdActive;
+        typedef Hash<socket_t,TcpServerSocket *> SrvHash;
+        SrvHash hServers;
+        typedef Hash<socket_t,Client *> ClientHash;
+        ClientHash hClients;
+        bool bAutoTick;
+    };
 }
 
 #endif
diff --git a/src/stable/sha1.cpp b/src/stable/sha1.cpp
index e6a85cc..30e5dc8 100644
--- a/src/stable/sha1.cpp
+++ b/src/stable/sha1.cpp
@@ -12,15 +12,15 @@
 #include "bu/sha1.h"

 

 Bu::Sha1::Sha1() :

-        uH0( 0x67452301 ),

-        uH1( 0xefcdab89 ),

-        uH2( 0x98badcfe ),

-        uH3( 0x10325476 ),

-        uH4( 0xc3d2e1f0 ),

-        iUnprocessedBytes( 0 ),

-        uTotalBytes( 0 )

+    uH0( 0x67452301 ),

+    uH1( 0xefcdab89 ),

+    uH2( 0x98badcfe ),

+    uH3( 0x10325476 ),

+    uH4( 0xc3d2e1f0 ),

+    iUnprocessedBytes( 0 ),

+    uTotalBytes( 0 )

 {

-        reset();

+    reset();

 }

 

 Bu::Sha1::~Sha1()

@@ -29,13 +29,13 @@ Bu::Sha1::~Sha1()
 

 void Bu::Sha1::reset()

 {

-        uH0 = 0x67452301;

-        uH1 = 0xefcdab89;

-        uH2 = 0x98badcfe;

-        uH3 = 0x10325476;

-        uH4 = 0xc3d2e1f0;

-        iUnprocessedBytes = 0;

-        uTotalBytes = 0;

+    uH0 = 0x67452301;

+    uH1 = 0xefcdab89;

+    uH2 = 0x98badcfe;

+    uH3 = 0x10325476;

+    uH4 = 0xc3d2e1f0;

+    iUnprocessedBytes = 0;

+    uTotalBytes = 0;

 }

 

 void Bu::Sha1::setSalt( const Bu::String & /*sSalt*/ )

@@ -44,151 +44,151 @@ void Bu::Sha1::setSalt( const Bu::String & /*sSalt*/ )
 

 void Bu::Sha1::addData( const void *sDataRaw, int iSize )

 {

-        const unsigned char *sData = (const unsigned char *)sDataRaw;

-        // add these bytes to the running total

-        uTotalBytes += iSize;

-

-        // repeat until all data is processed

-        while( iSize > 0 )

-        {

-                // number of bytes required to complete block

-                int iNeeded = 64 - iUnprocessedBytes;

-

-                // number of bytes to copy (use smaller of two)

-                int iToCopy = (iSize < iNeeded) ? iSize : iNeeded;

-

-                // Copy the bytes

-                memcpy( uBytes + iUnprocessedBytes, sData, iToCopy );

-

-                // Bytes have been copied

-                iSize -= iToCopy;

-                sData += iToCopy;

-                iUnprocessedBytes += iToCopy;

-                

-                // there is a full block

-                if( iUnprocessedBytes == 64 )

-                {

-                        process();

-                }

-        }

+    const unsigned char *sData = (const unsigned char *)sDataRaw;

+    // add these bytes to the running total

+    uTotalBytes += iSize;

+

+    // repeat until all data is processed

+    while( iSize > 0 )

+    {

+        // number of bytes required to complete block

+        int iNeeded = 64 - iUnprocessedBytes;

+

+        // number of bytes to copy (use smaller of two)

+        int iToCopy = (iSize < iNeeded) ? iSize : iNeeded;

+

+        // Copy the bytes

+        memcpy( uBytes + iUnprocessedBytes, sData, iToCopy );

+

+        // Bytes have been copied

+        iSize -= iToCopy;

+        sData += iToCopy;

+        iUnprocessedBytes += iToCopy;

+        

+        // there is a full block

+        if( iUnprocessedBytes == 64 )

+        {

+            process();

+        }

+    }

 }

 

 Bu::String Bu::Sha1::getResult()

 {

-        // save the message size

-        uint32_t totalBitsL = uTotalBytes << 3;

-        uint32_t totalBitsH = uTotalBytes >> 29;

-

-        // add 0x80 to the message

-        addData( "\x80", 1 );

-        

-        unsigned char footer[64] = {

-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

-

-        // block has no room for 8-byte filesize, so finish it

-        if( iUnprocessedBytes > 56 )

-                addData( (char*)footer, 64 - iUnprocessedBytes);

-

-        // how many zeros do we need

-        int iNeededZeros = 56 - iUnprocessedBytes;

-

-        // store file size (in bits) in big-endian format

-        toBigEndian( totalBitsH, footer + iNeededZeros );

-        toBigEndian( totalBitsL, footer + iNeededZeros + 4 );

-

-        // finish the final block

-        addData( (char*)footer, iNeededZeros + 8 );

-

-        Bu::String sRet( 20 );

-

-        unsigned char *digest = (unsigned char *)sRet.getStr();

-

-        // copy the digest bytes

-        toBigEndian( uH0, digest );

-        toBigEndian( uH1, digest + 4 );

-        toBigEndian( uH2, digest + 8 );

-        toBigEndian( uH3, digest + 12 );

-        toBigEndian( uH4, digest + 16 );

-

-        // return the digest

-        return sRet;

+    // save the message size

+    uint32_t totalBitsL = uTotalBytes << 3;

+    uint32_t totalBitsH = uTotalBytes >> 29;

+

+    // add 0x80 to the message

+    addData( "\x80", 1 );

+    

+    unsigned char footer[64] = {

+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

+

+    // block has no room for 8-byte filesize, so finish it

+    if( iUnprocessedBytes > 56 )

+        addData( (char*)footer, 64 - iUnprocessedBytes);

+

+    // how many zeros do we need

+    int iNeededZeros = 56 - iUnprocessedBytes;

+

+    // store file size (in bits) in big-endian format

+    toBigEndian( totalBitsH, footer + iNeededZeros );

+    toBigEndian( totalBitsL, footer + iNeededZeros + 4 );

+

+    // finish the final block

+    addData( (char*)footer, iNeededZeros + 8 );

+

+    Bu::String sRet( 20 );

+

+    unsigned char *digest = (unsigned char *)sRet.getStr();

+

+    // copy the digest bytes

+    toBigEndian( uH0, digest );

+    toBigEndian( uH1, digest + 4 );

+    toBigEndian( uH2, digest + 8 );

+    toBigEndian( uH3, digest + 12 );

+    toBigEndian( uH4, digest + 16 );

+

+    // return the digest

+    return sRet;

 }

 

 void Bu::Sha1::writeResult( Bu::Stream &sOut )

 {

-        sOut.write( getResult() );

+    sOut.write( getResult() );

 }

 

 void Bu::Sha1::process()

 {

-        int t;

-        uint32_t a, b, c, d, e, K, f, W[80];

-

-        // starting values

-        a = uH0;

-        b = uH1;

-        c = uH2;

-        d = uH3;

-        e = uH4;

-

-        // copy and expand the message block

-        for( t = 0; t < 16; t++ ) W[t] = (uBytes[t*4] << 24)

-                                                                        +(uBytes[t*4 + 1] << 16)

-                                                                        +(uBytes[t*4 + 2] << 8)

-                                                                        + uBytes[t*4 + 3];

-        for(; t< 80; t++ ) W[t] = lrot( W[t-3]^W[t-8]^W[t-14]^W[t-16], 1 );

-        

-        /* main loop */

-        uint32_t temp;

-        for( t = 0; t < 80; t++ )

-        {

-                if( t < 20 ) {

-                        K = 0x5a827999;

-                        f = (b & c) | ((~b) & d);

-                } else if( t < 40 ) {

-                        K = 0x6ed9eba1;

-                        f = b ^ c ^ d;

-                } else if( t < 60 ) {

-                        K = 0x8f1bbcdc;

-                        f = (b & c) | (b & d) | (c & d);

-                } else {

-                        K = 0xca62c1d6;

-                        f = b ^ c ^ d;

-                }

-                temp = lrot(a,5) + f + e + W[t] + K;

-                e = d;

-                d = c;

-                c = lrot(b,30);

-                b = a;

-                a = temp;

-                //printf( "t=%d %08x %08x %08x %08x %08x\n",t,a,b,c,d,e );

-        }

-

-        /* add variables */

-        uH0 += a;

-        uH1 += b;

-        uH2 += c;

-        uH3 += d;

-        uH4 += e;

-

-        //printf( "Current: %08x %08x %08x %08x %08x\n",H0,H1,H2,H3,H4 );

-        /* all bytes have been processed */

-        iUnprocessedBytes = 0;

+    int t;

+    uint32_t a, b, c, d, e, K, f, W[80];

+

+    // starting values

+    a = uH0;

+    b = uH1;

+    c = uH2;

+    d = uH3;

+    e = uH4;

+

+    // copy and expand the message block

+    for( t = 0; t < 16; t++ ) W[t] = (uBytes[t*4] << 24)

+                                    +(uBytes[t*4 + 1] << 16)

+                                    +(uBytes[t*4 + 2] << 8)

+                                    + uBytes[t*4 + 3];

+    for(; t< 80; t++ ) W[t] = lrot( W[t-3]^W[t-8]^W[t-14]^W[t-16], 1 );

+    

+    /* main loop */

+    uint32_t temp;

+    for( t = 0; t < 80; t++ )

+    {

+        if( t < 20 ) {

+            K = 0x5a827999;

+            f = (b & c) | ((~b) & d);

+        } else if( t < 40 ) {

+            K = 0x6ed9eba1;

+            f = b ^ c ^ d;

+        } else if( t < 60 ) {

+            K = 0x8f1bbcdc;

+            f = (b & c) | (b & d) | (c & d);

+        } else {

+            K = 0xca62c1d6;

+            f = b ^ c ^ d;

+        }

+        temp = lrot(a,5) + f + e + W[t] + K;

+        e = d;

+        d = c;

+        c = lrot(b,30);

+        b = a;

+        a = temp;

+        //printf( "t=%d %08x %08x %08x %08x %08x\n",t,a,b,c,d,e );

+    }

+

+    /* add variables */

+    uH0 += a;

+    uH1 += b;

+    uH2 += c;

+    uH3 += d;

+    uH4 += e;

+

+    //printf( "Current: %08x %08x %08x %08x %08x\n",H0,H1,H2,H3,H4 );

+    /* all bytes have been processed */

+    iUnprocessedBytes = 0;

 }

 

 uint32_t Bu::Sha1::lrot( uint32_t x, int bits )

 {

-        return (x<<bits) | (x>>(32 - bits));

+    return (x<<bits) | (x>>(32 - bits));

 }

 

 void Bu::Sha1::toBigEndian( uint32_t num, unsigned char* byte )

 {

-        byte[0] = (unsigned char)(num>>24);

-        byte[1] = (unsigned char)(num>>16);

-        byte[2] = (unsigned char)(num>>8);

-        byte[3] = (unsigned char)num;

+    byte[0] = (unsigned char)(num>>24);

+    byte[1] = (unsigned char)(num>>16);

+    byte[2] = (unsigned char)(num>>8);

+    byte[3] = (unsigned char)num;

 }

 

diff --git a/src/stable/sha1.h b/src/stable/sha1.h
index e861f94..f882473 100644
--- a/src/stable/sha1.h
+++ b/src/stable/sha1.h
@@ -13,41 +13,41 @@
 

 namespace Bu

 {

-        /**

-         * Calculates SHA-1 sums.  This is based strongly on code from Michael D.

-         * Leonhard who released his code under the terms of the MIT license,

-         * thank you!  Check out his website http://tamale.net he has a lot of

-         * cool stuff there.

-         */

-        class Sha1 : public CryptoHash

-        {

-        public:

-                Sha1();

-                virtual ~Sha1();

-

-                virtual void reset();

-                virtual void setSalt( const Bu::String &sSalt );

-                virtual void addData( const void *sData, int iSize );

-                using CryptoHash::addData;

-                virtual String getResult();

-                virtual void writeResult( Stream &sOut );

-

-                void update( const char* data, int num );

-                unsigned char* getDigest();

-

-                // utility methods

-

-        private:

-                static uint32_t lrot( uint32_t x, int bits );

-                static void toBigEndian( uint32_t in, unsigned char* out );

-                void process();

-        

-        private:

-                uint32_t uH0, uH1, uH2, uH3, uH4;

-                unsigned char uBytes[64];

-                int iUnprocessedBytes;

-                uint32_t uTotalBytes;

-        };

+    /**

+     * Calculates SHA-1 sums.  This is based strongly on code from Michael D.

+     * Leonhard who released his code under the terms of the MIT license,

+     * thank you!  Check out his website http://tamale.net he has a lot of

+     * cool stuff there.

+     */

+    class Sha1 : public CryptoHash

+    {

+    public:

+        Sha1();

+        virtual ~Sha1();

+

+        virtual void reset();

+        virtual void setSalt( const Bu::String &sSalt );

+        virtual void addData( const void *sData, int iSize );

+        using CryptoHash::addData;

+        virtual String getResult();

+        virtual void writeResult( Stream &sOut );

+

+        void update( const char* data, int num );

+        unsigned char* getDigest();

+

+        // utility methods

+

+    private:

+        static uint32_t lrot( uint32_t x, int bits );

+        static void toBigEndian( uint32_t in, unsigned char* out );

+        void process();

+    

+    private:

+        uint32_t uH0, uH1, uH2, uH3, uH4;

+        unsigned char uBytes[64];

+        int iUnprocessedBytes;

+        uint32_t uTotalBytes;

+    };

 };

 

 #endif

diff --git a/src/stable/sharedcore.h b/src/stable/sharedcore.h
index f000077..f8b9d4e 100644
--- a/src/stable/sharedcore.h
+++ b/src/stable/sharedcore.h
@@ -15,176 +15,176 @@
 
 namespace Bu
 {
-        /**
-         * A mechanism for creating classes that perform lazy copies.  The concept
-         * behind this is that instead of copying a large object when it is assigned
-         * or passed into a copy constructor we simply copy a pointer internally.
-         * The assumption is that many times when an object is passed by value we
-         * don't really want to keep the object around, we want the recipient to
-         * take ownership without allocating a new object.  This allows that to
-         * happen.
-         *
-         * When used properly this makes object copying essentially free (O(1),
-         * that is) and performs the actual copy when a user tries to modify the
-         * object.
-         *
-         * For example, lets look at something like the getKeys function in
-         * Bu::Hash.  When this function is called it creates a Bu::List of
-         * appropriate type, fills it with keys, and returns it.  This is a good
-         * way for this function to behave, there may be additional issues if the
-         * List object were allocated with new and not on the stack.  However,
-         * returning the List at the end of the function could potentially take
-         * a very long time depending on the size of the list and the type of the
-         * key.  In this case the getKeys function doesn't want ownership of the
-         * List object, and when it returns it, it's local copy will be destroyed.
-         *
-         * However, List inherits from SharedCore, which means that when it is
-         * returned all we do is copy a pointer to the "core" of the list, which
-         * is a very fast operatorion.  For a brief moment, before anyone can do
-         * anything else, there are two objects referencing the core of that single
-         * list.  However, the getKeys() function will destroy it's local copy
-         * before the calling function can use it's new copy.  That means that by
-         * the time the calling function can use it's new List of keys it is the
-         * only one with a reference to the core, and no copy will need to happen.
-         *
-         * Using SharedCore on your own classes is fairly straight forward.  There
-         * are only a couple of steps.  First, break the class into two classes.
-         * Move every variable from the original class (generally everything that's
-         * private) into the new class.  Then make the original class inherit from
-         * SharedCore.  The SharedCore template takes 2 parameters, first is the
-         * class it's inheriting from, second is the new core class.  Now, in your
-         * original class you will have one class variable, a pointer named core.
-         * All of your original variables will be accessable through core.  The next
-         * step is to access everything you used to through core, and to find 
-         * every function that may change data in the core.  At the top of every
-         * function that may change data you want to call _hardCopy().
-         *
-         * That's more or less it.  A more detailed guide will be written soon.
-         * @todo Write a guide for this.
-         */
-        template<typename Shell, typename Core>
-        class SharedCore
-        {
-                typedef class SharedCore<Shell, Core> _SharedType;
-        public:
-                SharedCore() :
-                        core( NULL ),
-                        iRefCount( NULL )
-                {
-                        core = _allocateCore();
-                        iRefCount = new int(1);
-                }
-
-                SharedCore( const _SharedType &rSrc ) :
-                        core( NULL ),
-                        iRefCount( NULL )
-                {
-                        _softCopy( rSrc );
-                }
-
-                virtual ~SharedCore()
-                {
-                        _deref();
-                }
-
-                SharedCore &operator=( const SharedCore &rhs )
-                {
-                        if( core == rhs.core )
-                                return *this;
-
-                        _softCopy( rhs );
-                        return *this;
-                }
-
-                int getRefCount() const
-                {
-                        return *iRefCount;
-                }
-
-                Shell clone() const
-                {
-                        Shell s( dynamic_cast<const Shell &>(*this) );
-                        s._hardCopy();
-                        return s;
-                }
-
-                bool isCoreShared( const Shell &rOther ) const
-                {
-                        return rOther.core == core;
-                }
-
-        protected:
-                Core *core;
-                void _hardCopy()
-                {
-                        if( !core || !iRefCount )
-                                return;
-                        if( (*iRefCount) == 1 )
-                                return;
-                        Core *copy = _copyCore( core );
-                        _deref();
-                        core = copy;
-                        iRefCount = new int( 1 );
-                }
-
-                /**
-                 * Reset core acts like a hard copy, except instead of providing a
-                 * standalone copy of the shared core, it provides a brand new core.
-                 *
-                 * Very useful in functions used to reset the state of an object.
-                 */
-                void _resetCore()
-                {
-                        if( core )
-                                _deref();
-                        core = _allocateCore();
-                        iRefCount = new int( 1 );
-                }
-
-                virtual Core *_allocateCore()
-                {
-                        return new Core();
-                }
-
-                virtual Core *_copyCore( Core *pSrc )
-                {
-                        return new Core( *pSrc );
-                }
-
-                virtual void _deallocateCore( Core *pSrc )
-                {
-                        delete pSrc;
-                }
-
-        private:
-                void _deref()
-                {
-                        if( (--(*iRefCount)) == 0 )
-                        {
-                                _deallocateCore( core );
-                                delete iRefCount;
-                        }
-                        core = NULL;
-                        iRefCount = NULL;
-                }
-
-                void _incRefCount()
-                {
-                        if( iRefCount && core )
-                                ++(*iRefCount);
-                }
-
-                void _softCopy( const _SharedType &rSrc )
-                {
-                        if( core )
-                                _deref();
-                        core = rSrc.core;
-                        iRefCount = rSrc.iRefCount;
-                        _incRefCount();
-                }
-
-                int *iRefCount;
-        };
+    /**
+     * A mechanism for creating classes that perform lazy copies.  The concept
+     * behind this is that instead of copying a large object when it is assigned
+     * or passed into a copy constructor we simply copy a pointer internally.
+     * The assumption is that many times when an object is passed by value we
+     * don't really want to keep the object around, we want the recipient to
+     * take ownership without allocating a new object.  This allows that to
+     * happen.
+     *
+     * When used properly this makes object copying essentially free (O(1),
+     * that is) and performs the actual copy when a user tries to modify the
+     * object.
+     *
+     * For example, lets look at something like the getKeys function in
+     * Bu::Hash.  When this function is called it creates a Bu::List of
+     * appropriate type, fills it with keys, and returns it.  This is a good
+     * way for this function to behave, there may be additional issues if the
+     * List object were allocated with new and not on the stack.  However,
+     * returning the List at the end of the function could potentially take
+     * a very long time depending on the size of the list and the type of the
+     * key.  In this case the getKeys function doesn't want ownership of the
+     * List object, and when it returns it, it's local copy will be destroyed.
+     *
+     * However, List inherits from SharedCore, which means that when it is
+     * returned all we do is copy a pointer to the "core" of the list, which
+     * is a very fast operatorion.  For a brief moment, before anyone can do
+     * anything else, there are two objects referencing the core of that single
+     * list.  However, the getKeys() function will destroy it's local copy
+     * before the calling function can use it's new copy.  That means that by
+     * the time the calling function can use it's new List of keys it is the
+     * only one with a reference to the core, and no copy will need to happen.
+     *
+     * Using SharedCore on your own classes is fairly straight forward.  There
+     * are only a couple of steps.  First, break the class into two classes.
+     * Move every variable from the original class (generally everything that's
+     * private) into the new class.  Then make the original class inherit from
+     * SharedCore.  The SharedCore template takes 2 parameters, first is the
+     * class it's inheriting from, second is the new core class.  Now, in your
+     * original class you will have one class variable, a pointer named core.
+     * All of your original variables will be accessable through core.  The next
+     * step is to access everything you used to through core, and to find 
+     * every function that may change data in the core.  At the top of every
+     * function that may change data you want to call _hardCopy().
+     *
+     * That's more or less it.  A more detailed guide will be written soon.
+     * @todo Write a guide for this.
+     */
+    template<typename Shell, typename Core>
+    class SharedCore
+    {
+        typedef class SharedCore<Shell, Core> _SharedType;
+    public:
+        SharedCore() :
+            core( NULL ),
+            iRefCount( NULL )
+        {
+            core = _allocateCore();
+            iRefCount = new int(1);
+        }
+
+        SharedCore( const _SharedType &rSrc ) :
+            core( NULL ),
+            iRefCount( NULL )
+        {
+            _softCopy( rSrc );
+        }
+
+        virtual ~SharedCore()
+        {
+            _deref();
+        }
+
+        SharedCore &operator=( const SharedCore &rhs )
+        {
+            if( core == rhs.core )
+                return *this;
+
+            _softCopy( rhs );
+            return *this;
+        }
+
+        int getRefCount() const
+        {
+            return *iRefCount;
+        }
+
+        Shell clone() const
+        {
+            Shell s( dynamic_cast<const Shell &>(*this) );
+            s._hardCopy();
+            return s;
+        }
+
+        bool isCoreShared( const Shell &rOther ) const
+        {
+            return rOther.core == core;
+        }
+
+    protected:
+        Core *core;
+        void _hardCopy()
+        {
+            if( !core || !iRefCount )
+                return;
+            if( (*iRefCount) == 1 )
+                return;
+            Core *copy = _copyCore( core );
+            _deref();
+            core = copy;
+            iRefCount = new int( 1 );
+        }
+
+        /**
+         * Reset core acts like a hard copy, except instead of providing a
+         * standalone copy of the shared core, it provides a brand new core.
+         *
+         * Very useful in functions used to reset the state of an object.
+         */
+        void _resetCore()
+        {
+            if( core )
+                _deref();
+            core = _allocateCore();
+            iRefCount = new int( 1 );
+        }
+
+        virtual Core *_allocateCore()
+        {
+            return new Core();
+        }
+
+        virtual Core *_copyCore( Core *pSrc )
+        {
+            return new Core( *pSrc );
+        }
+
+        virtual void _deallocateCore( Core *pSrc )
+        {
+            delete pSrc;
+        }
+
+    private:
+        void _deref()
+        {
+            if( (--(*iRefCount)) == 0 )
+            {
+                _deallocateCore( core );
+                delete iRefCount;
+            }
+            core = NULL;
+            iRefCount = NULL;
+        }
+
+        void _incRefCount()
+        {
+            if( iRefCount && core )
+                ++(*iRefCount);
+        }
+
+        void _softCopy( const _SharedType &rSrc )
+        {
+            if( core )
+                _deref();
+            core = rSrc.core;
+            iRefCount = rSrc.iRefCount;
+            _incRefCount();
+        }
+
+        int *iRefCount;
+    };
 };
 
 #undef fin
diff --git a/src/stable/singleton.h b/src/stable/singleton.h
index 6fe2777..27d907d 100644
--- a/src/stable/singleton.h
+++ b/src/stable/singleton.h
@@ -12,57 +12,57 @@
 
 namespace Bu
 {
-        /**
-         * Provides singleton functionality in a modular sort of way.  Make this the
-         * base class of any other class and you immediately gain singleton
-         * functionality.  Be sure to make your constructor and various functions use
-         * intellegent scoping.  Cleanup and instantiation are performed automatically
-         * for you at first use and program exit.  There are two things that you must
-         * do when using this template, first is to inherit from it with the name of
-         * your class filling in for T and then make this class a friend of your class.
-         *@code
-         * // Making the Single Singleton:
-         * class Single : public Singleton<Single>
-         * {
-         *              friend class Singleton<Single>;
-         *      protected:
-         *              Single();
-         *              ...
-         * };
-         @endcode
-         * You can still add public functions and variables to your new Singleton child
-         * class, but your constructor should be protected (hence the need for the
-         * friend decleration).
-         */
-        template <class T>
-        class Singleton
-        {
-        protected:
-                /**
-                 * Private constructor.  This constructor is empty but has a body so that
-                 * you can make your own override of it.  Be sure that you're override is
-                 * also protected.
-                 */
-                Singleton() {};
+    /**
+     * Provides singleton functionality in a modular sort of way.  Make this the
+     * base class of any other class and you immediately gain singleton
+     * functionality.  Be sure to make your constructor and various functions use
+     * intellegent scoping.  Cleanup and instantiation are performed automatically
+     * for you at first use and program exit.  There are two things that you must
+     * do when using this template, first is to inherit from it with the name of
+     * your class filling in for T and then make this class a friend of your class.
+     *@code
+     * // Making the Single Singleton:
+     * class Single : public Singleton<Single>
+     * {
+     *      friend class Singleton<Single>;
+     *  protected:
+     *      Single();
+     *      ...
+     * };
+     @endcode
+     * You can still add public functions and variables to your new Singleton child
+     * class, but your constructor should be protected (hence the need for the
+     * friend decleration).
+     */
+    template <class T>
+    class Singleton
+    {
+    protected:
+        /**
+         * Private constructor.  This constructor is empty but has a body so that
+         * you can make your own override of it.  Be sure that you're override is
+         * also protected.
+         */
+        Singleton() {};
 
-        private:
-                /**
-                 * Copy constructor, defined so that you could write your own as well.
-                 */
-                Singleton( const Singleton& );
+    private:
+        /**
+         * Copy constructor, defined so that you could write your own as well.
+         */
+        Singleton( const Singleton& );
 
-        public:
-                /**
-                 * Get a handle to the contained instance of the contained class.  It is
-                 * a reference.
-                 *@returns A reference to the contained object.
-                 */
-                static T &getInstance()
-                {
-                        static T i;
-                        return i;
-                }
-        };
+    public:
+        /**
+         * Get a handle to the contained instance of the contained class.  It is
+         * a reference.
+         *@returns A reference to the contained object.
+         */
+        static T &getInstance()
+        {
+            static T i;
+            return i;
+        }
+    };
 }
 
 #endif
diff --git a/src/stable/sio.cpp b/src/stable/sio.cpp
index 6a650ed..1ea30c2 100644
--- a/src/stable/sio.cpp
+++ b/src/stable/sio.cpp
@@ -16,51 +16,51 @@ Bu::Formatter Bu::serr( Bu::serrRaw );
 
 namespace Bu
 {
-        class PrintEndAction : public Bu::String::FormatProxyEndAction
-        {
-        public:
-                PrintEndAction( Bu::Stream &s, bool bEndLn ) :
-                        s( s ),
-                        bEndLn( bEndLn )
-                {
-                }
+    class PrintEndAction : public Bu::String::FormatProxyEndAction
+    {
+    public:
+        PrintEndAction( Bu::Stream &s, bool bEndLn ) :
+            s( s ),
+            bEndLn( bEndLn )
+        {
+        }
 
-                virtual ~PrintEndAction()
-                {
-                }
+        virtual ~PrintEndAction()
+        {
+        }
 
-                virtual void operator()( const Bu::String &sFinal )
-                {
-                        s.write( sFinal.getStr(), sFinal.getSize() );
-                        if( bEndLn )
-                        {
-                                s.write("\n", 1);
-                                s.flush();
-                        }
-                }
+        virtual void operator()( const Bu::String &sFinal )
+        {
+            s.write( sFinal.getStr(), sFinal.getSize() );
+            if( bEndLn )
+            {
+                s.write("\n", 1);
+                s.flush();
+            }
+        }
 
-                Bu::Stream &s;
-                bool bEndLn;
-        };
+        Bu::Stream &s;
+        bool bEndLn;
+    };
 }
 
 Bu::String::FormatProxy Bu::print( Bu::Stream &s, const Bu::String &str )
 {
-        return str.format( new Bu::PrintEndAction( s, false ) );
+    return str.format( new Bu::PrintEndAction( s, false ) );
 }
 
 Bu::String::FormatProxy Bu::print( const Bu::String &str )
 {
-        return print( sioRaw, str );
+    return print( sioRaw, str );
 }
 
 Bu::String::FormatProxy Bu::println( Bu::Stream &s, const Bu::String &str )
 {
-        return str.format( new Bu::PrintEndAction( s, true ) );
+    return str.format( new Bu::PrintEndAction( s, true ) );
 }
 
 Bu::String::FormatProxy Bu::println( const Bu::String &str )
 {
-        return println( sioRaw, str );
+    return println( sioRaw, str );
 }
 
diff --git a/src/stable/sio.h b/src/stable/sio.h
index 2d4a104..ddaea1b 100644
--- a/src/stable/sio.h
+++ b/src/stable/sio.h
@@ -12,18 +12,18 @@
 
 namespace Bu
 {
-        class StreamStack;
+    class StreamStack;
 
-        extern Bu::StreamStack sioRaw;
-        extern Bu::Formatter sio;
-        extern Bu::StreamStack serrRaw;
-        extern Bu::Formatter serr;
+    extern Bu::StreamStack sioRaw;
+    extern Bu::Formatter sio;
+    extern Bu::StreamStack serrRaw;
+    extern Bu::Formatter serr;
 
-        Bu::String::FormatProxy print( Bu::Stream &s, const Bu::String &str );
-        Bu::String::FormatProxy print( const Bu::String &str );
+    Bu::String::FormatProxy print( Bu::Stream &s, const Bu::String &str );
+    Bu::String::FormatProxy print( const Bu::String &str );
 
-        Bu::String::FormatProxy println( Bu::Stream &s, const Bu::String &str );
-        Bu::String::FormatProxy println( const Bu::String &str );
+    Bu::String::FormatProxy println( Bu::Stream &s, const Bu::String &str );
+    Bu::String::FormatProxy println( const Bu::String &str );
 };
 
 #endif
diff --git a/src/stable/sptr.h b/src/stable/sptr.h
index 58ea223..6a9c340 100644
--- a/src/stable/sptr.h
+++ b/src/stable/sptr.h
@@ -13,217 +13,217 @@
 
 namespace Bu
 {
-        template<typename T> class SPtr;
-        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src );
-
-        /**
-         *@ingroup Containers
-         */
-        template<typename T>
-        class SPtr
-        {
-                template<typename Tb, typename Ta>
-                friend SPtr<Tb> SPtrCast( SPtr<Ta> pt );
-        public:
-                SPtr() :
-                        pRefCnt( NULL ),
-                        pData( NULL )
-                {
-                }
-
-                ~SPtr()
-                {
-                        decCount();
-                }
-
-                SPtr( const SPtr<T> &src ) :
-                        pRefCnt( src.pRefCnt ),
-                        pData( src.pData )
-                {
-                        if( pRefCnt )
-                                (*pRefCnt) += 1;
-                }
-
-                SPtr( T *pSrc ) :
-                        pRefCnt( NULL ),
-                        pData( pSrc )
-                {
-                        if( pData )
-                        {
-                                pRefCnt = new int32_t;
-                                (*pRefCnt) = 1;
-                        }
-                }
-
-                /**
-                 * Get the number of references to this pointer.
-                 *@returns (int32_t) The number of references to this pointer.
-                 */
-                int32_t getRefCount() const
-                {
-                        return *pRefCnt;
-                }
-
-                void clear()
-                {
-                        decCount();
-                        pRefCnt = NULL;
-                        pData = NULL;
-                }
-
-                /**
-                 * Pointer access operator.
-                 *@returns (const T *)
-                 */
-                const T *operator->() const
-                {
-                        return pData;
-                }
-
-                /**
-                 * Dereference operator.
-                 *@returns (const T &) The value at the end of the pointer.
-                 */
-                const T &operator*() const
-                {
-                        return *pData;
-                }
-                
-                /**
-                 * Pointer access operator.
-                 *@returns (T *)
-                 */
-                T *operator->()
-                {
-                        return pData;
-                }
-
-                /**
-                 * Dereference operator.
-                 *@returns (T &) The value at the end of the pointer.
-                 */
-                T &operator*()
-                {
-                        return *pData;
-                }
-
-                /**
-                 * Assignment operator.
-                 *@param src (const SPtr<T> &)
-                 */
-                SPtr<T> operator=( const SPtr<T> &src )
-                {
-                        decCount();
-                        pRefCnt = src.pRefCnt;
-                        pData = src.pData;
-                        if( pRefCnt )
-                                (*pRefCnt) += 1;
-
-                        return *this;
-                }
-
-                /**
-                 * Assignment operator.
-                 *@param src (const SPtr<T> &)
-                 */
-                const SPtr<T> operator=( const SPtr<T> &src ) const
-                {
-                        decCount();
-                        pRefCnt = src.pRefCnt;
-                        pData = src.pData;
-                        if( pRefCnt )
-                                (*pRefCnt) += 1;
-
-                        return *this;
-                }
-
-                /**
-                 * Equals comparison operator.
-                 *@param src (const SPtr<T> &) The SPtr to compare to.
-                 *@returns (bool) Are the equal?
-                 */
-                bool operator==( const SPtr<T> &src ) const
-                {
-                        return pData == src.pData;
-                }
-
-                /**
-                 * Equals comparison operator.
-                 *@param src (const T *) The pointer to compare to.
-                 *@returns (bool) Are the equal?
-                 */
-                bool operator==( const T *src ) const
-                {
-                        return pData == src;
-                }
-                
-                /**
-                 * Not equals comparison operator.
-                 *@param src (const SPtr<T> &) The SPtr to compare to.
-                 *@returns (bool) Are the equal?
-                 */
-                bool operator!=( const SPtr<T> &src ) const
-                {
-                        return !(pData == src.pData);
-                }
-
-                /**
-                 * Not equals comparison operator.
-                 *@param src (const T *) The pointer to compare to.
-                 *@returns (bool) Are the equal?
-                 */
-                bool operator!=( const T *src ) const
-                {
-                        return !(pData == src);
-                }
-
-                /**
-                 * Boolean cast operator. Do we have a pointer?
-                 */
-                operator bool() const
-                {
-                        return pRefCnt != NULL;
-                }
-
-                /**
-                 * Do we have a pointer?
-                 *@returns (bool) Do we have a pointer?
-                 */
-                bool isSet() const
-                {
-                        return pRefCnt != NULL;
-                }
-
-        private:
-                void decCount() const
-                {
-                        if( pRefCnt )
-                        {
-                                (*pRefCnt) -= 1;
-                                //printf("Decrementing ref-count to %d\n", *pRefCnt );
-                                if( (*pRefCnt) == 0 )
-                                {
-                                        delete pRefCnt;
-                                        delete pData;
-                                        pRefCnt = NULL;
-                                        pData = NULL;
-                                }
-                        }
-                }
-
-                mutable int32_t *pRefCnt;
-                mutable T *pData;
-        };
-
-        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src )
-        {
-                SPtr<Tb> ret;
-                ret.pRefCnt = src.pRefCnt;
-                ret.pData = dynamic_cast<Tb *>(src.pData);
-                if( ret.pRefCnt )
-                        (*(ret.pRefCnt)) += 1;
-                return ret;
-        }
+    template<typename T> class SPtr;
+    template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src );
+
+    /**
+     *@ingroup Containers
+     */
+    template<typename T>
+    class SPtr
+    {
+        template<typename Tb, typename Ta>
+        friend SPtr<Tb> SPtrCast( SPtr<Ta> pt );
+    public:
+        SPtr() :
+            pRefCnt( NULL ),
+            pData( NULL )
+        {
+        }
+
+        ~SPtr()
+        {
+            decCount();
+        }
+
+        SPtr( const SPtr<T> &src ) :
+            pRefCnt( src.pRefCnt ),
+            pData( src.pData )
+        {
+            if( pRefCnt )
+                (*pRefCnt) += 1;
+        }
+
+        SPtr( T *pSrc ) :
+            pRefCnt( NULL ),
+            pData( pSrc )
+        {
+            if( pData )
+            {
+                pRefCnt = new int32_t;
+                (*pRefCnt) = 1;
+            }
+        }
+
+        /**
+         * Get the number of references to this pointer.
+         *@returns (int32_t) The number of references to this pointer.
+         */
+        int32_t getRefCount() const
+        {
+            return *pRefCnt;
+        }
+
+        void clear()
+        {
+            decCount();
+            pRefCnt = NULL;
+            pData = NULL;
+        }
+
+        /**
+         * Pointer access operator.
+         *@returns (const T *)
+         */
+        const T *operator->() const
+        {
+            return pData;
+        }
+
+        /**
+         * Dereference operator.
+         *@returns (const T &) The value at the end of the pointer.
+         */
+        const T &operator*() const
+        {
+            return *pData;
+        }
+        
+        /**
+         * Pointer access operator.
+         *@returns (T *)
+         */
+        T *operator->()
+        {
+            return pData;
+        }
+
+        /**
+         * Dereference operator.
+         *@returns (T &) The value at the end of the pointer.
+         */
+        T &operator*()
+        {
+            return *pData;
+        }
+
+        /**
+         * Assignment operator.
+         *@param src (const SPtr<T> &)
+         */
+        SPtr<T> operator=( const SPtr<T> &src )
+        {
+            decCount();
+            pRefCnt = src.pRefCnt;
+            pData = src.pData;
+            if( pRefCnt )
+                (*pRefCnt) += 1;
+
+            return *this;
+        }
+
+        /**
+         * Assignment operator.
+         *@param src (const SPtr<T> &)
+         */
+        const SPtr<T> operator=( const SPtr<T> &src ) const
+        {
+            decCount();
+            pRefCnt = src.pRefCnt;
+            pData = src.pData;
+            if( pRefCnt )
+                (*pRefCnt) += 1;
+
+            return *this;
+        }
+
+        /**
+         * Equals comparison operator.
+         *@param src (const SPtr<T> &) The SPtr to compare to.
+         *@returns (bool) Are the equal?
+         */
+        bool operator==( const SPtr<T> &src ) const
+        {
+            return pData == src.pData;
+        }
+
+        /**
+         * Equals comparison operator.
+         *@param src (const T *) The pointer to compare to.
+         *@returns (bool) Are the equal?
+         */
+        bool operator==( const T *src ) const
+        {
+            return pData == src;
+        }
+        
+        /**
+         * Not equals comparison operator.
+         *@param src (const SPtr<T> &) The SPtr to compare to.
+         *@returns (bool) Are the equal?
+         */
+        bool operator!=( const SPtr<T> &src ) const
+        {
+            return !(pData == src.pData);
+        }
+
+        /**
+         * Not equals comparison operator.
+         *@param src (const T *) The pointer to compare to.
+         *@returns (bool) Are the equal?
+         */
+        bool operator!=( const T *src ) const
+        {
+            return !(pData == src);
+        }
+
+        /**
+         * Boolean cast operator. Do we have a pointer?
+         */
+        operator bool() const
+        {
+            return pRefCnt != NULL;
+        }
+
+        /**
+         * Do we have a pointer?
+         *@returns (bool) Do we have a pointer?
+         */
+        bool isSet() const
+        {
+            return pRefCnt != NULL;
+        }
+
+    private:
+        void decCount() const
+        {
+            if( pRefCnt )
+            {
+                (*pRefCnt) -= 1;
+                //printf("Decrementing ref-count to %d\n", *pRefCnt );
+                if( (*pRefCnt) == 0 )
+                {
+                    delete pRefCnt;
+                    delete pData;
+                    pRefCnt = NULL;
+                    pData = NULL;
+                }
+            }
+        }
+
+        mutable int32_t *pRefCnt;
+        mutable T *pData;
+    };
+
+    template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src )
+    {
+        SPtr<Tb> ret;
+        ret.pRefCnt = src.pRefCnt;
+        ret.pData = dynamic_cast<Tb *>(src.pData);
+        if( ret.pRefCnt )
+            (*(ret.pRefCnt)) += 1;
+        return ret;
+    }
 }
 
 #endif
diff --git a/src/stable/stack.h b/src/stable/stack.h
index f60907d..6b5f65a 100644
--- a/src/stable/stack.h
+++ b/src/stable/stack.h
@@ -13,73 +13,73 @@
 
 namespace Bu
 {
-        template<typename value, typename valuealloc=std::allocator<value> >
-        class Stack
-        {
-        private:
-                typedef struct Chunk
-                {
-                        value *pValue;
-                        Chunk *pPrev;
-                } Chunk;
-        public:
-                Stack() :
-                        pTop( NULL )
-                {
-                }
+    template<typename value, typename valuealloc=std::allocator<value> >
+    class Stack
+    {
+    private:
+        typedef struct Chunk
+        {
+            value *pValue;
+            Chunk *pPrev;
+        } Chunk;
+    public:
+        Stack() :
+            pTop( NULL )
+        {
+        }
 
-                virtual ~Stack()
-                {
-                }
+        virtual ~Stack()
+        {
+        }
 
-                void push( const value &v )
-                {
-                        Chunk *pChnk = new Chunk;
-                        pChnk->pValue = va.allocate( 1 );
-                        va.construct( pChnk->pValue, v );
-                        pChnk->pPrev = pTop;
-                        pTop = pChnk;
-                }
+        void push( const value &v )
+        {
+            Chunk *pChnk = new Chunk;
+            pChnk->pValue = va.allocate( 1 );
+            va.construct( pChnk->pValue, v );
+            pChnk->pPrev = pTop;
+            pTop = pChnk;
+        }
 
-                value &peek()
-                {
-                        return *pTop->pValue;
-                }
-                
-                value &top()
-                {
-                        return *pTop->pValue;
-                }
+        value &peek()
+        {
+            return *pTop->pValue;
+        }
+        
+        value &top()
+        {
+            return *pTop->pValue;
+        }
 
-                value pop()
-                {
-                        value ret( *pTop->pValue );
-                        
-                        Chunk *pChnk = pTop;
-                        pTop = pTop->pPrev;
+        value pop()
+        {
+            value ret( *pTop->pValue );
+            
+            Chunk *pChnk = pTop;
+            pTop = pTop->pPrev;
 
-                        va.destroy( pChnk->pValue );
-                        va.deallocate( pChnk->pValue, 1 );
-                        delete pChnk;
+            va.destroy( pChnk->pValue );
+            va.deallocate( pChnk->pValue, 1 );
+            delete pChnk;
 
-                        return ret;
-                }
+            return ret;
+        }
 
-                void clear()
-                {
-                        while( !isEmpty() )
-                                pop();
-                }
+        void clear()
+        {
+            while( !isEmpty() )
+                pop();
+        }
 
-                bool isEmpty()
-                {
-                        return pTop == NULL;
-                }
+        bool isEmpty()
+        {
+            return pTop == NULL;
+        }
 
-        private:
-                Chunk *pTop;
-                valuealloc va;
-        };
+    private:
+        Chunk *pTop;
+        valuealloc va;
+    };
 }
 
 #endif
diff --git a/src/stable/staticmembuf.cpp b/src/stable/staticmembuf.cpp
index d470916..43f098b 100644
--- a/src/stable/staticmembuf.cpp
+++ b/src/stable/staticmembuf.cpp
@@ -10,9 +10,9 @@
 using namespace Bu;
 
 Bu::StaticMemBuf::StaticMemBuf( const void *pData, size iSize ) :
-        pData( pData ),
-        iSize( iSize ),
-        nPos( 0 )
+    pData( pData ),
+    iSize( iSize ),
+    nPos( 0 )
 {
 }
 
@@ -26,54 +26,54 @@ void Bu::StaticMemBuf::close()
 
 size Bu::StaticMemBuf::read( void *pBuf, size nBytes )
 {
-        if( iSize-nPos < nBytes )
-                nBytes = iSize-nPos;
+    if( iSize-nPos < nBytes )
+        nBytes = iSize-nPos;
 
-        memcpy( pBuf, ((char *)pData)+nPos, nBytes );
-        nPos += nBytes;
+    memcpy( pBuf, ((char *)pData)+nPos, nBytes );
+    nPos += nBytes;
 
-        return nBytes;
+    return nBytes;
 }
-        
+    
 size Bu::StaticMemBuf::write( const void *, size )
 {
-        return -1;
+    return -1;
 }
 
 size Bu::StaticMemBuf::tell()
 {
-        return nPos;
+    return nPos;
 }
 
 void Bu::StaticMemBuf::seek( size offset )
 {
-        nPos += offset;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > iSize ) nPos = iSize;
+    nPos += offset;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > iSize ) nPos = iSize;
 }
 
 void Bu::StaticMemBuf::setPos( size pos )
 {
-        nPos = pos;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > iSize ) nPos = iSize;
+    nPos = pos;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > iSize ) nPos = iSize;
 }
 
 void Bu::StaticMemBuf::setPosEnd( size pos )
 {
-        nPos = iSize-pos;
-        if( nPos < 0 ) nPos = 0;
-        else if( nPos > iSize ) nPos = iSize;
+    nPos = iSize-pos;
+    if( nPos < 0 ) nPos = 0;
+    else if( nPos > iSize ) nPos = iSize;
 }
 
 bool Bu::StaticMemBuf::isEos()
 {
-        return (nPos == iSize);
+    return (nPos == iSize);
 }
 
 bool Bu::StaticMemBuf::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::StaticMemBuf::flush()
@@ -82,32 +82,32 @@ void Bu::StaticMemBuf::flush()
 
 bool Bu::StaticMemBuf::canRead()
 {
-        return !isEos();
+    return !isEos();
 }
 
 bool Bu::StaticMemBuf::canWrite()
 {
-        return false;
+    return false;
 }
 
 bool Bu::StaticMemBuf::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StaticMemBuf::isWritable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::StaticMemBuf::isSeekable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StaticMemBuf::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::StaticMemBuf::setBlocking( bool )
@@ -120,16 +120,16 @@ void Bu::StaticMemBuf::setSize( size )
 
 Bu::size Bu::StaticMemBuf::getSize() const
 {
-        return iSize;
+    return iSize;
 }
 
 Bu::size Bu::StaticMemBuf::getBlockSize() const
 {
-        return iSize;
+    return iSize;
 }
 
 Bu::String Bu::StaticMemBuf::getLocation() const
 {
-        return "";
+    return "";
 }
 
diff --git a/src/stable/staticmembuf.h b/src/stable/staticmembuf.h
index 332e27d..2be05a0 100644
--- a/src/stable/staticmembuf.h
+++ b/src/stable/staticmembuf.h
@@ -15,51 +15,51 @@
 
 namespace Bu
 {
-        /**
-         * An immutable, read-only memory buffer.  Construct this buffer around a
-         * block of raw memory, provide the length of the block, and you can read
-         * from that block via this class as though it were a normal stream.
-         *
-         * Use this class instead of MemBuf when you have a string already, and
-         * don't need to change it.  MemBuf will make a copy of your string for
-         * it's own use (often) and this will not (ever).
-         *@ingroup Streams
-         */
-        class StaticMemBuf : public Stream
-        {
-        public:
-                StaticMemBuf( const void *pData, size iSize );
-                virtual ~StaticMemBuf();
+    /**
+     * An immutable, read-only memory buffer.  Construct this buffer around a
+     * block of raw memory, provide the length of the block, and you can read
+     * from that block via this class as though it were a normal stream.
+     *
+     * Use this class instead of MemBuf when you have a string already, and
+     * don't need to change it.  MemBuf will make a copy of your string for
+     * it's own use (often) and this will not (ever).
+     *@ingroup Streams
+     */
+    class StaticMemBuf : public Stream
+    {
+    public:
+        StaticMemBuf( const void *pData, size iSize );
+        virtual ~StaticMemBuf();
 
-                virtual void close();
-                virtual size read( void *pBuf, size iBytes );
+        virtual void close();
+        virtual size read( void *pBuf, size iBytes );
 
-                virtual size write( const void *pBuf, size iBytes );
-                using Stream::write;
-                virtual size tell();
-                virtual void seek( size offset );
-                virtual void setPos( size pos );
-                virtual void setPosEnd( size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( size iSize );
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size write( const void *pBuf, size iBytes );
+        using Stream::write;
+        virtual size tell();
+        virtual void seek( size offset );
+        virtual void setPos( size pos );
+        virtual void setPosEnd( size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( size iSize );
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-        private:
-                const void *pData;
-                size iSize;
-                size nPos;
-        };
+    private:
+        const void *pData;
+        size iSize;
+        size nPos;
+    };
 }
 
 #endif
diff --git a/src/stable/stdstream.cpp b/src/stable/stdstream.cpp
index 25ad8d4..9cd216d 100644
--- a/src/stable/stdstream.cpp
+++ b/src/stable/stdstream.cpp
@@ -9,7 +9,7 @@
 #include "bu/stdstream.h"
 
 Bu::StdStream::StdStream( OutMode eOut ) :
-        eOut( eOut )
+    eOut( eOut )
 {
 }
 
@@ -23,17 +23,17 @@ void Bu::StdStream::close()
 
 Bu::size Bu::StdStream::read( void *pBuf, Bu::size nBytes )
 {
-        return fread( pBuf, 1, nBytes, stdin );
+    return fread( pBuf, 1, nBytes, stdin );
 }
 
 Bu::size Bu::StdStream::write( const void *pBuf, Bu::size nBytes )
 {
-        return fwrite( pBuf, 1, nBytes, eOut==StdOut?stdout:stderr );
+    return fwrite( pBuf, 1, nBytes, eOut==StdOut?stdout:stderr );
 }
 
 Bu::size Bu::StdStream::tell()
 {
-        return 0;
+    return 0;
 }
 
 void Bu::StdStream::seek( Bu::size )
@@ -50,47 +50,47 @@ void Bu::StdStream::setPosEnd( Bu::size )
 
 bool Bu::StdStream::isEos()
 {
-        return false;
+    return false;
 }
 
 bool Bu::StdStream::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::StdStream::flush()
 {
-        fflush( eOut==StdOut?stdout:stderr );
+    fflush( eOut==StdOut?stdout:stderr );
 }
 
 bool Bu::StdStream::canRead()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StdStream::canWrite()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StdStream::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StdStream::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::StdStream::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::StdStream::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::StdStream::setBlocking( bool )
@@ -103,16 +103,16 @@ void Bu::StdStream::setSize( Bu::size )
 
 Bu::size Bu::StdStream::getSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::StdStream::getBlockSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::String Bu::StdStream::getLocation() const
 {
-        return "";
+    return "";
 }
 
diff --git a/src/stable/stdstream.h b/src/stable/stdstream.h
index d71d95d..80c0fab 100644
--- a/src/stable/stdstream.h
+++ b/src/stable/stdstream.h
@@ -13,46 +13,46 @@
 
 namespace Bu
 {
-        /**
-         *@ingroup Streams
-         */
-        class StdStream : public Stream
-        {
-        public:
-                enum OutMode
-                {
-                        StdOut,
-                        StdError
-                };
-                StdStream( OutMode eOut=StdOut );
-                virtual ~StdStream();
+    /**
+     *@ingroup Streams
+     */
+    class StdStream : public Stream
+    {
+    public:
+        enum OutMode
+        {
+            StdOut,
+            StdError
+        };
+        StdStream( OutMode eOut=StdOut );
+        virtual ~StdStream();
 
-                virtual void close();
-                virtual size read( void *pBuf, size nBytes );
-                virtual size write( const void *pBuf, size nBytes );
-                using Stream::write;
-                virtual size tell();
-                virtual void seek( size offset );
-                virtual void setPos( size pos );
-                virtual void setPosEnd( size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( size iSize );
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-        
-        private:
-                OutMode eOut;
-        };
+        virtual void close();
+        virtual size read( void *pBuf, size nBytes );
+        virtual size write( const void *pBuf, size nBytes );
+        using Stream::write;
+        virtual size tell();
+        virtual void seek( size offset );
+        virtual void setPos( size pos );
+        virtual void setPosEnd( size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( size iSize );
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+    
+    private:
+        OutMode eOut;
+    };
 }
 
 #endif
diff --git a/src/stable/stream.cpp b/src/stable/stream.cpp
index 23a7f0f..551d657 100644
--- a/src/stable/stream.cpp
+++ b/src/stable/stream.cpp
@@ -17,37 +17,37 @@ Bu::Stream::~Stream()
 
 Bu::String Bu::Stream::readLine()
 {
-        Bu::String sRet;
-        
-        for(;;)
-        {
-                char s;
-                if( read( &s, 1 ) == 0 )
-                        return sRet;
-                if( s == '\n' || s == '\r' )
-                        return sRet;
-                sRet.append( s );
-        }
+    Bu::String sRet;
+    
+    for(;;)
+    {
+        char s;
+        if( read( &s, 1 ) == 0 )
+            return sRet;
+        if( s == '\n' || s == '\r' )
+            return sRet;
+        sRet.append( s );
+    }
 }
 
 Bu::String Bu::Stream::readAll()
 {
-        Bu::String sRet;
-        char buf[4096];
-
-        while( !isEos() )
-        {
-                int iRead = read( buf, 4096 );
-                if( iRead == 0 )
-                        return sRet;
-                sRet.append( buf, iRead );
-        }
-
-        return sRet;
+    Bu::String sRet;
+    char buf[4096];
+
+    while( !isEos() )
+    {
+        int iRead = read( buf, 4096 );
+        if( iRead == 0 )
+            return sRet;
+        sRet.append( buf, iRead );
+    }
+
+    return sRet;
 }
 
 Bu::size Bu::Stream::write( const Bu::String &sBuf )
 {
-        return write( sBuf.getStr(), sBuf.getSize() );
+    return write( sBuf.getStr(), sBuf.getSize() );
 }
 
diff --git a/src/stable/stream.h b/src/stable/stream.h
index 21e090e..a76e5fd 100644
--- a/src/stable/stream.h
+++ b/src/stable/stream.h
@@ -17,189 +17,189 @@
 
 namespace Bu
 {
-        /**
-         * The basis for a completely general data transport mechanism.  Anything
-         * that inherits from this should provide at least the basic read and/or
-         * write functions, and very probably the close function.  Any functions
-         * that aren't supported should throw an exception if called.
-         *
-         * The constructor of a child class should pretty much universally be used
-         * to open the stream.  I can't think of anything that should require an
-         * exception.
-         *@ingroup Streams
-         */
-        class Stream
-        {
-        public:
-                Stream();
-                virtual ~Stream();
-
-                /**
-                 * Close the stream.
-                 */
-                virtual void close() = 0;
-
-                /**
-                 * Read data from the stream into a buffer.
-                 *@param pBuf (void *) Buffer which will be filled.
-                 *@param nBytes (size_t) Max data to read.
-                 *@returns (size_t) Amount of data read.
-                 */
-                virtual size read( void *pBuf, size iBytes ) = 0;
-
-                /**
-                 * Attempts to read a complete line from the stream.  This will stop
-                 * reading when it has reached the end of the stream, or runs out of
-                 * data in a non-blocking stream.
-                 *@returns The line read, not including newline character.
-                 */
-                virtual Bu::String readLine();
-
-                /**
-                 * Reads all data from the current position onward until isEos returns
-                 * true and returns it as a Bu::String.  This will also return if no
-                 * data is available and the stream is in non-blocking mode.  This
-                 * function is intended for very particular circumstances and is often
-                 * not the most efficient way to access the data that you would like.
-                 *@returns The entire stream contents.
-                 */
-                virtual Bu::String readAll();
-
-                /**
-                 * Write data to the stream.
-                 *@param pBuf (const void *) The data to be written.
-                 *@param nBytes (size_t) Amount of data to write from pBuf.
-                 *@returns (size_t) Amount of data actually written.
-                 */
-                virtual size write( const void *pBuf, size iBytes ) = 0;
-
-                virtual size write( const Bu::String &sBuf );
-
-                /**
-                 * Get the current position in the stream.
-                 *@returns (long) The current position in the stream.
-                 */
-                virtual size tell() = 0;
-
-                /**
-                 * Seek to a position in the stream relative to the current position.
-                 *@param offset (long) Offset from current position to seek to.
-                 */
-                virtual void seek( size offset ) = 0;
-
-                /**
-                 * Set position in the stream relative to the start of the stream.
-                 *@param pos (long) The position.
-                 */
-                virtual void setPos( size pos ) = 0;
-
-                /**
-                 * Set position in the stream relative to the end of the stream.
-                 *@param pos (long) The position.
-                 */
-                virtual void setPosEnd( size pos ) = 0;
-
-                /**
-                 * Are we at the end of the stream?
-                 *@returns (bool) Are we at the end of the stream?
-                 */
-                virtual bool isEos() = 0;
-
-                /**
-                 * Is the stream open?
-                 *@returns (bool) Is the stream open?
-                 */
-                virtual bool isOpen() = 0;
-
-                /**
-                 * Flush any data still held in buffers.
-                 */
-                virtual void flush() = 0;
-
-                /**
-                 * In non-blocking streams this indicates if a read operation will
-                 * return data at the moment or not.  In blocking streams this should
-                 * return the same value as isEos().
-                 */
-                virtual bool canRead() = 0;
-
-                /**
-                 * In non-blocking streams this indicates if a write operation will
-                 * actually write one or more bytes.  In some cases writing is not
-                 * allowed (e.g. internal buffers are full) temporarilly.  In blocking
-                 * streams this should return the same value as isWritable.
-                 */
-                virtual bool canWrite() = 0;
-
-                /**
-                 * Indicates if the stream is capable of read operations.  This does not
-                 * indicate if such operations will return useful data, see canRead for
-                 * that.
-                 */
-                virtual bool isReadable() = 0;
-
-                /**
-                 * Indicates if the stream is capable of write operations.  This does
-                 * not indicate if such operations will succeed or fail, see canWrite
-                 * for that.
-                 */
-                virtual bool isWritable() = 0;
-
-                /**
-                 * Indicates if the stream is capable of seek operations.  This is
-                 * generally false for non-blocking streams.  Some buffered streams may
-                 * support limited in-buffer seeking.
-                 */
-                virtual bool isSeekable() = 0;
-
-                /**
-                 * Are we currently set to block mode?
-                 *@returns (bool)
-                 */
-                virtual bool isBlocking() = 0;
-
-                /**
-                 * Set stream to blocking or non-blocking mode.
-                 *@param bBlocking (bool) Whether we should block or not.
-                 */
-                virtual void setBlocking( bool bBlocking=true ) = 0;
-
-                /**
-                 * Set the size of the stream, this does not apply to many types of
-                 * streams.  For those that it does apply to, data will be added or
-                 * removed from the end of the stream, but the content of the added
-                 * data is undefined.
-                 */
-                virtual void setSize( size iSize ) = 0;
-
-                /**
-                 * Returns the size of the stream if the stream can have a size.  For
-                 * streams that do not (sockets, pipes, etc.) this should throw an
-                 * unsupported exception.
-                 */
-                virtual size getSize() const = 0;
-
-                /**
-                 * Returns the block-size of the stream, if it has one.  This should
-                 * throw an unsupported exception.  In some cases the block size
-                 * returned will not represent quite the same thing, for example,
-                 * sockets will return their MTU, while files will return the
-                 * filesystem's block size, and memory buffers will throw an exception.
-                 */
-                virtual size getBlockSize() const = 0;
-
-                /**
-                 * If possible, this returns a string that can be used to describe how
-                 * to access the open stream.  Not all streams support this, such as
-                 * MemBuf, but for files it may give you a path to a file, for a socket
-                 * it may give you an ip address, etc.  If it isn't supported, an empty
-                 * string may be returned.
-                 */
-                virtual Bu::String getLocation() const = 0;
-
-        private:
-
-        };
+    /**
+     * The basis for a completely general data transport mechanism.  Anything
+     * that inherits from this should provide at least the basic read and/or
+     * write functions, and very probably the close function.  Any functions
+     * that aren't supported should throw an exception if called.
+     *
+     * The constructor of a child class should pretty much universally be used
+     * to open the stream.  I can't think of anything that should require an
+     * exception.
+     *@ingroup Streams
+     */
+    class Stream
+    {
+    public:
+        Stream();
+        virtual ~Stream();
+
+        /**
+         * Close the stream.
+         */
+        virtual void close() = 0;
+
+        /**
+         * Read data from the stream into a buffer.
+         *@param pBuf (void *) Buffer which will be filled.
+         *@param nBytes (size_t) Max data to read.
+         *@returns (size_t) Amount of data read.
+         */
+        virtual size read( void *pBuf, size iBytes ) = 0;
+
+        /**
+         * Attempts to read a complete line from the stream.  This will stop
+         * reading when it has reached the end of the stream, or runs out of
+         * data in a non-blocking stream.
+         *@returns The line read, not including newline character.
+         */
+        virtual Bu::String readLine();
+
+        /**
+         * Reads all data from the current position onward until isEos returns
+         * true and returns it as a Bu::String.  This will also return if no
+         * data is available and the stream is in non-blocking mode.  This
+         * function is intended for very particular circumstances and is often
+         * not the most efficient way to access the data that you would like.
+         *@returns The entire stream contents.
+         */
+        virtual Bu::String readAll();
+
+        /**
+         * Write data to the stream.
+         *@param pBuf (const void *) The data to be written.
+         *@param nBytes (size_t) Amount of data to write from pBuf.
+         *@returns (size_t) Amount of data actually written.
+         */
+        virtual size write( const void *pBuf, size iBytes ) = 0;
+
+        virtual size write( const Bu::String &sBuf );
+
+        /**
+         * Get the current position in the stream.
+         *@returns (long) The current position in the stream.
+         */
+        virtual size tell() = 0;
+
+        /**
+         * Seek to a position in the stream relative to the current position.
+         *@param offset (long) Offset from current position to seek to.
+         */
+        virtual void seek( size offset ) = 0;
+
+        /**
+         * Set position in the stream relative to the start of the stream.
+         *@param pos (long) The position.
+         */
+        virtual void setPos( size pos ) = 0;
+
+        /**
+         * Set position in the stream relative to the end of the stream.
+         *@param pos (long) The position.
+         */
+        virtual void setPosEnd( size pos ) = 0;
+
+        /**
+         * Are we at the end of the stream?
+         *@returns (bool) Are we at the end of the stream?
+         */
+        virtual bool isEos() = 0;
+
+        /**
+         * Is the stream open?
+         *@returns (bool) Is the stream open?
+         */
+        virtual bool isOpen() = 0;
+
+        /**
+         * Flush any data still held in buffers.
+         */
+        virtual void flush() = 0;
+
+        /**
+         * In non-blocking streams this indicates if a read operation will
+         * return data at the moment or not.  In blocking streams this should
+         * return the same value as isEos().
+         */
+        virtual bool canRead() = 0;
+
+        /**
+         * In non-blocking streams this indicates if a write operation will
+         * actually write one or more bytes.  In some cases writing is not
+         * allowed (e.g. internal buffers are full) temporarilly.  In blocking
+         * streams this should return the same value as isWritable.
+         */
+        virtual bool canWrite() = 0;
+
+        /**
+         * Indicates if the stream is capable of read operations.  This does not
+         * indicate if such operations will return useful data, see canRead for
+         * that.
+         */
+        virtual bool isReadable() = 0;
+
+        /**
+         * Indicates if the stream is capable of write operations.  This does
+         * not indicate if such operations will succeed or fail, see canWrite
+         * for that.
+         */
+        virtual bool isWritable() = 0;
+
+        /**
+         * Indicates if the stream is capable of seek operations.  This is
+         * generally false for non-blocking streams.  Some buffered streams may
+         * support limited in-buffer seeking.
+         */
+        virtual bool isSeekable() = 0;
+
+        /**
+         * Are we currently set to block mode?
+         *@returns (bool)
+         */
+        virtual bool isBlocking() = 0;
+
+        /**
+         * Set stream to blocking or non-blocking mode.
+         *@param bBlocking (bool) Whether we should block or not.
+         */
+        virtual void setBlocking( bool bBlocking=true ) = 0;
+
+        /**
+         * Set the size of the stream, this does not apply to many types of
+         * streams.  For those that it does apply to, data will be added or
+         * removed from the end of the stream, but the content of the added
+         * data is undefined.
+         */
+        virtual void setSize( size iSize ) = 0;
+
+        /**
+         * Returns the size of the stream if the stream can have a size.  For
+         * streams that do not (sockets, pipes, etc.) this should throw an
+         * unsupported exception.
+         */
+        virtual size getSize() const = 0;
+
+        /**
+         * Returns the block-size of the stream, if it has one.  This should
+         * throw an unsupported exception.  In some cases the block size
+         * returned will not represent quite the same thing, for example,
+         * sockets will return their MTU, while files will return the
+         * filesystem's block size, and memory buffers will throw an exception.
+         */
+        virtual size getBlockSize() const = 0;
+
+        /**
+         * If possible, this returns a string that can be used to describe how
+         * to access the open stream.  Not all streams support this, such as
+         * MemBuf, but for files it may give you a path to a file, for a socket
+         * it may give you an ip address, etc.  If it isn't supported, an empty
+         * string may be returned.
+         */
+        virtual Bu::String getLocation() const = 0;
+
+    private:
+
+    };
 }
 
 #endif
diff --git a/src/stable/streamstack.cpp b/src/stable/streamstack.cpp
index 47ae5c0..deafbcf 100644
--- a/src/stable/streamstack.cpp
+++ b/src/stable/streamstack.cpp
@@ -13,222 +13,222 @@ Bu::StreamStack::StreamStack()
 
 Bu::StreamStack::StreamStack( Bu::Stream *pStream )
 {
-        lFilts.prepend( pStream );
+    lFilts.prepend( pStream );
 }
 
 Bu::StreamStack::~StreamStack()
 {
-        clear();
+    clear();
 }
 
 bool Bu::StreamStack::isEmpty()
 {
-        return lFilts.isEmpty();
+    return lFilts.isEmpty();
 }
 
 bool Bu::StreamStack::hasStream()
 {
-        return !lFilts.isEmpty();
+    return !lFilts.isEmpty();
 }
 
 void Bu::StreamStack::setStream( Bu::Stream *pStream )
 {
-        if( !lFilts.isEmpty() )
-                throw Bu::ExceptionBase("There is already a stream set.");
+    if( !lFilts.isEmpty() )
+        throw Bu::ExceptionBase("There is already a stream set.");
 
-        lFilts.prepend( pStream );
+    lFilts.prepend( pStream );
 }
 
 void Bu::StreamStack::clear()
 {
-        for( FilterList::iterator i = lFilts.begin(); i; i++ )
-        {
-                delete *i;
-        }
+    for( FilterList::iterator i = lFilts.begin(); i; i++ )
+    {
+        delete *i;
+    }
 
-        lFilts.clear();
+    lFilts.clear();
 }
 
 void Bu::StreamStack::popFilter()
 {
-        if( lFilts.isEmpty() )
-                return;
+    if( lFilts.isEmpty() )
+        return;
 
-        delete lFilts.first();
-        lFilts.erase( lFilts.begin() );
+    delete lFilts.first();
+    lFilts.erase( lFilts.begin() );
 }
 
 Bu::Stream *Bu::StreamStack::getTop()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first();
+    return lFilts.first();
 }
 
 Bu::Stream *Bu::StreamStack::getStream()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.last();
+    return lFilts.last();
 }
 
 void Bu::StreamStack::close()
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->close();
+    lFilts.first()->close();
 }
 
 Bu::size Bu::StreamStack::read( void *pBuf, Bu::size nBytes )
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->read( pBuf, nBytes );
+    return lFilts.first()->read( pBuf, nBytes );
 }
 
 Bu::size Bu::StreamStack::write( const void *pBuf, Bu::size nBytes )
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->write( pBuf, nBytes );
+    return lFilts.first()->write( pBuf, nBytes );
 }
 
 Bu::size Bu::StreamStack::write( const Bu::String &sBuf )
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->write( sBuf );
+    return lFilts.first()->write( sBuf );
 }
 
 Bu::size Bu::StreamStack::tell()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->tell();
+    return lFilts.first()->tell();
 }
 
 void Bu::StreamStack::seek( Bu::size offset )
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->seek( offset );
+    lFilts.first()->seek( offset );
 }
 
 void Bu::StreamStack::setPos( Bu::size pos )
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->setPos( pos );
+    lFilts.first()->setPos( pos );
 }
 
 void Bu::StreamStack::setPosEnd( Bu::size pos )
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->setPosEnd( pos );
+    lFilts.first()->setPosEnd( pos );
 }
 
 bool Bu::StreamStack::isEos()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isEos();
+    return lFilts.first()->isEos();
 }
 
 bool Bu::StreamStack::isOpen()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isOpen();
+    return lFilts.first()->isOpen();
 }
 
 void Bu::StreamStack::flush()
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->flush();
+    lFilts.first()->flush();
 }
 
 bool Bu::StreamStack::canRead()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->canRead();
+    return lFilts.first()->canRead();
 }
 
 bool Bu::StreamStack::canWrite()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->canWrite();
+    return lFilts.first()->canWrite();
 }
 
 bool Bu::StreamStack::isReadable()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isReadable();
+    return lFilts.first()->isReadable();
 }
 
 bool Bu::StreamStack::isWritable()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isWritable();
+    return lFilts.first()->isWritable();
 }
 
 bool Bu::StreamStack::isSeekable()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isSeekable();
+    return lFilts.first()->isSeekable();
 }
 
 bool Bu::StreamStack::isBlocking()
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->isBlocking();
+    return lFilts.first()->isBlocking();
 }
 
 void Bu::StreamStack::setBlocking( bool bBlocking )
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->setBlocking( bBlocking );
+    lFilts.first()->setBlocking( bBlocking );
 }
 
 void Bu::StreamStack::setSize( Bu::size iSize )
 {
-        checkStack();
+    checkStack();
 
-        lFilts.first()->setSize( iSize );
+    lFilts.first()->setSize( iSize );
 }
 
 Bu::size Bu::StreamStack::getSize() const
 {
-        checkStack();
-        
-        return lFilts.first()->getSize();
+    checkStack();
+    
+    return lFilts.first()->getSize();
 }
 
 Bu::size Bu::StreamStack::getBlockSize() const
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->getBlockSize();
+    return lFilts.first()->getBlockSize();
 }
 
 Bu::String Bu::StreamStack::getLocation() const
 {
-        checkStack();
+    checkStack();
 
-        return lFilts.first()->getLocation();
+    return lFilts.first()->getLocation();
 }
 
 inline void Bu::StreamStack::checkStack() const
 {
-        if( lFilts.isEmpty() )
-                throw Bu::ExceptionBase("StreamStack is empty.");
+    if( lFilts.isEmpty() )
+        throw Bu::ExceptionBase("StreamStack is empty.");
 }
 
diff --git a/src/stable/streamstack.h b/src/stable/streamstack.h
index 36c2e11..06a3214 100644
--- a/src/stable/streamstack.h
+++ b/src/stable/streamstack.h
@@ -14,131 +14,131 @@
 
 namespace Bu
 {
-        class StreamStack : public Bu::Stream
-        {
-        private:
-                typedef Bu::List<Bu::Stream *> FilterList;
-
-        public:
-                StreamStack();
-                StreamStack( Bu::Stream *pStream );
-                virtual ~StreamStack();
-
-                bool isEmpty();
-                bool hasStream();
-                void setStream( Bu::Stream *pStream );
-
-                void clear();
-                void popFilter();
-                Bu::Stream *getTop();
-
-                Bu::Stream *getStream();
-
-                template<typename filter>
-                Bu::Stream *findFilter()
-                {
-                        for( FilterList::iterator i = lFilts.begin(); i; i++ )
-                        {
-                                if( typeid(**i) == typeid( filter ) )
-                                {
-                                        return *i;
-                                }
-                        }
-
-                        throw Bu::ExceptionBase("Filter not found.");
-                }
-
-                template<typename filter>
-                void pushFilter()
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first() );
-                        lFilts.prepend( pFlt );
-                }
-
-                template<typename filter, typename p1t>
-                void pushFilter( p1t p1 )
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first(), p1 );
-                        lFilts.prepend( pFlt );
-                }
-
-                template<typename filter, typename p1t, typename p2t>
-                void pushFilter( p1t p1, p2t p2 )
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first(), p1, p2 );
-                        lFilts.prepend( pFlt );
-                }
-
-                template<typename filter, typename p1t, typename p2t, typename p3t>
-                void pushFilter( p1t p1, p2t p2, p3t p3 )
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first(), p1, p2, p3 );
-                        lFilts.prepend( pFlt );
-                }
-
-                template<typename filter, typename p1t, typename p2t, typename p3t,
-                        typename p4t>
-                void pushFilter( p1t p1, p2t p2, p3t p3, p4t p4 )
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first(), p1, p2, p3, p4 );
-                        lFilts.prepend( pFlt );
-                }
-
-                template<typename filter, typename p1t, typename p2t, typename p3t,
-                        typename p4t, typename p5t>
-                void pushFilter( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
-                {
-                        checkStack();
-
-                        filter *pFlt = new filter( *lFilts.first(), p1, p2, p3, p4, p5 );
-                        lFilts.prepend( pFlt );
-                }
-
-                //
-                // Everything below here merely passes on the call to the top of the
-                // stream stack.
-                //
-
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-
-                virtual Bu::size write( const Bu::String &sBuf );
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-                virtual void flush();
-                virtual bool canRead();
-                virtual bool canWrite();
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-                virtual void setSize( Bu::size iSize );
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-
-        private:
-                void checkStack() const;
-
-        private:
-                FilterList lFilts;
-        };
+    class StreamStack : public Bu::Stream
+    {
+    private:
+        typedef Bu::List<Bu::Stream *> FilterList;
+
+    public:
+        StreamStack();
+        StreamStack( Bu::Stream *pStream );
+        virtual ~StreamStack();
+
+        bool isEmpty();
+        bool hasStream();
+        void setStream( Bu::Stream *pStream );
+
+        void clear();
+        void popFilter();
+        Bu::Stream *getTop();
+
+        Bu::Stream *getStream();
+
+        template<typename filter>
+        Bu::Stream *findFilter()
+        {
+            for( FilterList::iterator i = lFilts.begin(); i; i++ )
+            {
+                if( typeid(**i) == typeid( filter ) )
+                {
+                    return *i;
+                }
+            }
+
+            throw Bu::ExceptionBase("Filter not found.");
+        }
+
+        template<typename filter>
+        void pushFilter()
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first() );
+            lFilts.prepend( pFlt );
+        }
+
+        template<typename filter, typename p1t>
+        void pushFilter( p1t p1 )
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first(), p1 );
+            lFilts.prepend( pFlt );
+        }
+
+        template<typename filter, typename p1t, typename p2t>
+        void pushFilter( p1t p1, p2t p2 )
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first(), p1, p2 );
+            lFilts.prepend( pFlt );
+        }
+
+        template<typename filter, typename p1t, typename p2t, typename p3t>
+        void pushFilter( p1t p1, p2t p2, p3t p3 )
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first(), p1, p2, p3 );
+            lFilts.prepend( pFlt );
+        }
+
+        template<typename filter, typename p1t, typename p2t, typename p3t,
+            typename p4t>
+        void pushFilter( p1t p1, p2t p2, p3t p3, p4t p4 )
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first(), p1, p2, p3, p4 );
+            lFilts.prepend( pFlt );
+        }
+
+        template<typename filter, typename p1t, typename p2t, typename p3t,
+            typename p4t, typename p5t>
+        void pushFilter( p1t p1, p2t p2, p3t p3, p4t p4, p5t p5 )
+        {
+            checkStack();
+
+            filter *pFlt = new filter( *lFilts.first(), p1, p2, p3, p4, p5 );
+            lFilts.prepend( pFlt );
+        }
+
+        //
+        // Everything below here merely passes on the call to the top of the
+        // stream stack.
+        //
+
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+
+        virtual Bu::size write( const Bu::String &sBuf );
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+        virtual void flush();
+        virtual bool canRead();
+        virtual bool canWrite();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+        virtual void setSize( Bu::size iSize );
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+
+    private:
+        void checkStack() const;
+
+    private:
+        FilterList lFilts;
+    };
 };
 
 #endif
diff --git a/src/stable/strfilter.h b/src/stable/strfilter.h
index 8da0a3f..c910574 100644
--- a/src/stable/strfilter.h
+++ b/src/stable/strfilter.h
@@ -6,119 +6,119 @@
 
 namespace Bu
 {
-        //
-        // Encoders
-        //
-        template<typename tFilter>
-        Bu::String encodeStr( const Bu::String &sIn )
-        {
-                Bu::MemBuf mb;
-                {
-                        tFilter fEnc( mb );
-                        fEnc.write( sIn.getStr(), sIn.getSize() );
-                }
-                return mb.getString();
-        }
+    //
+    // Encoders
+    //
+    template<typename tFilter>
+    Bu::String encodeStr( const Bu::String &sIn )
+    {
+        Bu::MemBuf mb;
+        {
+            tFilter fEnc( mb );
+            fEnc.write( sIn.getStr(), sIn.getSize() );
+        }
+        return mb.getString();
+    }
 
-        template<typename tFilter, typename p1t>
-        Bu::String encodeStr( const Bu::String &sIn, p1t p1 )
-        {
-                Bu::MemBuf mb;
-                {
-                        tFilter fEnc( mb, p1 );
-                        fEnc.write( sIn.getStr(), sIn.getSize() );
-                }
-                return mb.getString();
-        }
+    template<typename tFilter, typename p1t>
+    Bu::String encodeStr( const Bu::String &sIn, p1t p1 )
+    {
+        Bu::MemBuf mb;
+        {
+            tFilter fEnc( mb, p1 );
+            fEnc.write( sIn.getStr(), sIn.getSize() );
+        }
+        return mb.getString();
+    }
 
-        template<typename tFilter, typename p1t, typename p2t>
-        Bu::String encodeStr( const Bu::String &sIn, p1t p1, p2t p2 )
-        {
-                Bu::MemBuf mb;
-                {
-                        tFilter fEnc( mb, p1, p2 );
-                        fEnc.write( sIn.getStr(), sIn.getSize() );
-                }
-                return mb.getString();
-        }
+    template<typename tFilter, typename p1t, typename p2t>
+    Bu::String encodeStr( const Bu::String &sIn, p1t p1, p2t p2 )
+    {
+        Bu::MemBuf mb;
+        {
+            tFilter fEnc( mb, p1, p2 );
+            fEnc.write( sIn.getStr(), sIn.getSize() );
+        }
+        return mb.getString();
+    }
 
-        template<typename tFilter, typename p1t, typename p2t, typename p3t>
-        Bu::String encodeStr( const Bu::String &sIn, p1t p1, p2t p2, p3t p3 )
-        {
-                Bu::MemBuf mb;
-                {
-                        tFilter fEnc( mb, p1, p2 );
-                        fEnc.write( sIn.getStr(), sIn.getSize() );
-                }
-                return mb.getString();
-        }
+    template<typename tFilter, typename p1t, typename p2t, typename p3t>
+    Bu::String encodeStr( const Bu::String &sIn, p1t p1, p2t p2, p3t p3 )
+    {
+        Bu::MemBuf mb;
+        {
+            tFilter fEnc( mb, p1, p2 );
+            fEnc.write( sIn.getStr(), sIn.getSize() );
+        }
+        return mb.getString();
+    }
 
-        //
-        // Decoders
-        //
-        template<typename tFilter>
-        Bu::String decodeStr( const Bu::String &sIn )
-        {
-                Bu::MemBuf mb( sIn );
-                tFilter fDec( mb );
-                char buf[1024];
-                String sRet;
-                for(;;)
-                {
-                        int iRead = fDec.read( buf, 1024 );
-                        if( iRead == 0 )
-                                return sRet;
-                        sRet.append( buf, iRead );
-                }
-        }
-        
-        template<typename tFilter, typename p1t>
-        Bu::String decodeStr( const Bu::String &sIn, p1t p1 )
-        {
-                Bu::MemBuf mb( sIn );
-                tFilter fDec( mb, p1 );
-                char buf[1024];
-                String sRet;
-                for(;;)
-                {
-                        int iRead = fDec.read( buf, 1024 );
-                        if( iRead == 0 )
-                                return sRet;
-                        sRet.append( buf, iRead );
-                }
-        }
-        
-        template<typename tFilter, typename p1t, typename p2t>
-        Bu::String decodeStr( const Bu::String &sIn, p1t p1, p2t p2 )
-        {
-                Bu::MemBuf mb( sIn );
-                tFilter fDec( mb, p1, p2 );
-                char buf[1024];
-                String sRet;
-                for(;;)
-                {
-                        int iRead = fDec.read( buf, 1024 );
-                        if( iRead == 0 )
-                                return sRet;
-                        sRet.append( buf, iRead );
-                }
-        }
-        
-        template<typename tFilter, typename p1t, typename p2t, typename p3t>
-        Bu::String decodeStr( const Bu::String &sIn, p1t p1, p2t p2, p3t p3 )
-        {
-                Bu::MemBuf mb( sIn );
-                tFilter fDec( mb, p1, p2, p3 );
-                char buf[1024];
-                String sRet;
-                for(;;)
-                {
-                        int iRead = fDec.read( buf, 1024 );
-                        if( iRead == 0 )
-                                return sRet;
-                        sRet.append( buf, iRead );
-                }
-        }
+    //
+    // Decoders
+    //
+    template<typename tFilter>
+    Bu::String decodeStr( const Bu::String &sIn )
+    {
+        Bu::MemBuf mb( sIn );
+        tFilter fDec( mb );
+        char buf[1024];
+        String sRet;
+        for(;;)
+        {
+            int iRead = fDec.read( buf, 1024 );
+            if( iRead == 0 )
+                return sRet;
+            sRet.append( buf, iRead );
+        }
+    }
+    
+    template<typename tFilter, typename p1t>
+    Bu::String decodeStr( const Bu::String &sIn, p1t p1 )
+    {
+        Bu::MemBuf mb( sIn );
+        tFilter fDec( mb, p1 );
+        char buf[1024];
+        String sRet;
+        for(;;)
+        {
+            int iRead = fDec.read( buf, 1024 );
+            if( iRead == 0 )
+                return sRet;
+            sRet.append( buf, iRead );
+        }
+    }
+    
+    template<typename tFilter, typename p1t, typename p2t>
+    Bu::String decodeStr( const Bu::String &sIn, p1t p1, p2t p2 )
+    {
+        Bu::MemBuf mb( sIn );
+        tFilter fDec( mb, p1, p2 );
+        char buf[1024];
+        String sRet;
+        for(;;)
+        {
+            int iRead = fDec.read( buf, 1024 );
+            if( iRead == 0 )
+                return sRet;
+            sRet.append( buf, iRead );
+        }
+    }
+    
+    template<typename tFilter, typename p1t, typename p2t, typename p3t>
+    Bu::String decodeStr( const Bu::String &sIn, p1t p1, p2t p2, p3t p3 )
+    {
+        Bu::MemBuf mb( sIn );
+        tFilter fDec( mb, p1, p2, p3 );
+        char buf[1024];
+        String sRet;
+        for(;;)
+        {
+            int iRead = fDec.read( buf, 1024 );
+            if( iRead == 0 )
+                return sRet;
+            sRet.append( buf, iRead );
+        }
+    }
 };
 
 #endif
diff --git a/src/stable/string.cpp b/src/stable/string.cpp
index dd484fd..d073ec6 100644
--- a/src/stable/string.cpp
+++ b/src/stable/string.cpp
@@ -14,117 +14,117 @@
 #include "bu/formatter.h"
 #include <stdlib.h>
 
-#define nMinSize        (256)
+#define nMinSize    (256)
 
 Bu::StringCore::StringCore() :
-        nLength( 0 ),
-        pFirst( NULL ),
-        pLast( NULL )
+    nLength( 0 ),
+    pFirst( NULL ),
+    pLast( NULL )
 {
 }
 
 Bu::StringCore::StringCore( const StringCore &rSrc ) :
-        nLength( rSrc.nLength ),
-        pFirst( NULL ),
-        pLast( NULL )
-{
-        if( rSrc.pFirst == NULL || rSrc.nLength == 0 )
-        {
-                pFirst = pLast = NULL;
-        }
-        else
-        {
-                pFirst = pLast = newChunk( nLength );
-                Chunk *pLink = rSrc.pFirst;
-                int iPos = 0;
-                while( pLink != NULL )
-                {
-                        memcpy( pFirst->pData+iPos, pLink->pData, pLink->nLength );
-                        iPos += pLink->nLength;
-                        pLink = pLink->pNext;
-                }
-        }
+    nLength( rSrc.nLength ),
+    pFirst( NULL ),
+    pLast( NULL )
+{
+    if( rSrc.pFirst == NULL || rSrc.nLength == 0 )
+    {
+        pFirst = pLast = NULL;
+    }
+    else
+    {
+        pFirst = pLast = newChunk( nLength );
+        Chunk *pLink = rSrc.pFirst;
+        int iPos = 0;
+        while( pLink != NULL )
+        {
+            memcpy( pFirst->pData+iPos, pLink->pData, pLink->nLength );
+            iPos += pLink->nLength;
+            pLink = pLink->pNext;
+        }
+    }
 }
 
 Bu::StringCore::~StringCore()
 {
-        clear();
+    clear();
 }
 
 void Bu::StringCore::clear() const
 {
-        if( pFirst == NULL )
-                return;
-
-        Chunk *i = pFirst;
-        for(;;)
-        {
-                Chunk *n = i->pNext;
-                delete[] i->pData;
-                delete i;
-                if( n == NULL )
-                        break;
-                i = n;
-        }
-        pFirst = pLast = NULL;
-        nLength = 0;
-}       
+    if( pFirst == NULL )
+        return;
+
+    Chunk *i = pFirst;
+    for(;;)
+    {
+        Chunk *n = i->pNext;
+        delete[] i->pData;
+        delete i;
+        if( n == NULL )
+            break;
+        i = n;
+    }
+    pFirst = pLast = NULL;
+    nLength = 0;
+}   
 
 Bu::StringCore::Chunk *Bu::StringCore::newChunk() const
 {
-        Chunk *pNew = new Chunk;
-        pNew->pNext = NULL;
-        return pNew;
+    Chunk *pNew = new Chunk;
+    pNew->pNext = NULL;
+    return pNew;
 }
 
 Bu::StringCore::Chunk *Bu::StringCore::newChunk( long nLen ) const
 {
-        Chunk *pNew = new Chunk;
-        pNew->pNext = NULL;
-        pNew->nLength = nLen;
-        pNew->pData = new char[(nLen<nMinSize)?(nMinSize):(nLen)+1];
-        pNew->pData[nLen] = (char)0;
-        return pNew;
+    Chunk *pNew = new Chunk;
+    pNew->pNext = NULL;
+    pNew->nLength = nLen;
+    pNew->pData = new char[(nLen<nMinSize)?(nMinSize):(nLen)+1];
+    pNew->pData[nLen] = (char)0;
+    return pNew;
 }
 
 Bu::StringCore::Chunk *Bu::StringCore::copyChunk(
-                Bu::StringCore::Chunk *pSrc ) const
+        Bu::StringCore::Chunk *pSrc ) const
 {
-        Chunk *pNew = new Chunk;
-        pNew->pNext = pSrc->pNext;
-        pNew->nLength = pSrc->nLength;
-        pNew->pData = new char[
-                (pNew->nLength<nMinSize)?(nMinSize):(pNew->nLength)+1
-                ];
-        memcpy( pNew->pData, pSrc->pData, pSrc->nLength );
-        pNew->pData[pNew->nLength] = (char)0;
-        return pNew;
+    Chunk *pNew = new Chunk;
+    pNew->pNext = pSrc->pNext;
+    pNew->nLength = pSrc->nLength;
+    pNew->pData = new char[
+        (pNew->nLength<nMinSize)?(nMinSize):(pNew->nLength)+1
+        ];
+    memcpy( pNew->pData, pSrc->pData, pSrc->nLength );
+    pNew->pData[pNew->nLength] = (char)0;
+    return pNew;
 }
 
 void Bu::StringCore::appendChunk( Bu::StringCore::Chunk *pNewChunk )
 {
-        if( pFirst == NULL )
-                pLast = pFirst = pNewChunk;
-        else
-        {
-                pLast->pNext = pNewChunk;
-                pLast = pNewChunk;
-        }
+    if( pFirst == NULL )
+        pLast = pFirst = pNewChunk;
+    else
+    {
+        pLast->pNext = pNewChunk;
+        pLast = pNewChunk;
+    }
 
-        nLength += pNewChunk->nLength;
+    nLength += pNewChunk->nLength;
 }
 
 void Bu::StringCore::prependChunk( Bu::StringCore::Chunk *pNewChunk )
 {
-        if( pFirst == NULL )
-                pLast = pFirst = pNewChunk;
-        else
-        {
-                pNewChunk->pNext = pFirst;
-                pFirst = pNewChunk;
-        }
+    if( pFirst == NULL )
+        pLast = pFirst = pNewChunk;
+    else
+    {
+        pNewChunk->pNext = pFirst;
+        pFirst = pNewChunk;
+    }
 
-        nLength += pNewChunk->nLength;
+    nLength += pNewChunk->nLength;
 }
 
 Bu::String::String()
@@ -133,44 +133,44 @@ Bu::String::String()
 
 Bu::String::String( const char *pData )
 {
-        append( pData );
+    append( pData );
 }
 
 Bu::String::String( const char *pData, long nLength )
 {
-        append( pData, nLength );
+    append( pData, nLength );
 }
 
 Bu::String::String( const Bu::String &rSrc ) :
-        Bu::SharedCore<Bu::String, Bu::StringCore>( rSrc )
+    Bu::SharedCore<Bu::String, Bu::StringCore>( rSrc )
 {
 }
 
 Bu::String::String( const Bu::String &rSrc, long nLength )
 {
-        append( rSrc, nLength );
+    append( rSrc, nLength );
 }
 
 Bu::String::String( const Bu::String &rSrc, long nStart, long nLength )
 {
-        append( rSrc, nStart, nLength );
+    append( rSrc, nStart, nLength );
 }
 
 Bu::String::String( long nSize )
 {
-        core->pFirst = core->pLast = core->newChunk( nSize );
-        core->nLength = nSize;
+    core->pFirst = core->pLast = core->newChunk( nSize );
+    core->nLength = nSize;
 }
 
 Bu::String::String( const Bu::String::const_iterator &s )
 {
-        append( s );
+    append( s );
 }
 
 Bu::String::String( const Bu::String::const_iterator &s,
-                const Bu::String::const_iterator &e )
+        const Bu::String::const_iterator &e )
 {
-        append( s, e );
+    append( s, e );
 }
 
 Bu::String::~String()
@@ -179,1049 +179,1049 @@ Bu::String::~String()
 
 void Bu::String::append( const char *pData )
 {
-        if( !pData ) return;
-        long nLen;
-        for( nLen = 0; pData[nLen] != (char)0; nLen++ ) { }
+    if( !pData ) return;
+    long nLen;
+    for( nLen = 0; pData[nLen] != (char)0; nLen++ ) { }
 
-        append( pData, 0, nLen );
+    append( pData, 0, nLen );
 }
 
 void Bu::String::append( const char *pData, long nLen )
 {
-        append( pData, 0, nLen );
+    append( pData, 0, nLen );
 }
 
 void Bu::String::append( const char *pData, long nStart, long nLen )
 {
-        if( !pData ) return;
-        if( nLen <= 0 )
-                return;
-
-        pData += nStart;
-
-        _hardCopy();
-
-        if( core->pLast && core->pLast->nLength < nMinSize )
-        {
-                int nAmnt = nMinSize - core->pLast->nLength;
-                if( nAmnt > nLen )
-                        nAmnt = nLen;
-                memcpy(
-                        core->pLast->pData+core->pLast->nLength,
-                        pData,
-                        nAmnt
-                   );
-                pData += nAmnt;
-                core->pLast->nLength += nAmnt;
-                nLen -= nAmnt;
-                core->nLength += nAmnt;
-        }
-
-        if( nLen > 0 )
-        {
-                Chunk *pNew = core->newChunk( nLen );
-                memcpy( pNew->pData, pData, nLen );
-                core->appendChunk( pNew );
-//                              core->nLength += nLen;
-        }
+    if( !pData ) return;
+    if( nLen <= 0 )
+        return;
+
+    pData += nStart;
+
+    _hardCopy();
+
+    if( core->pLast && core->pLast->nLength < nMinSize )
+    {
+        int nAmnt = nMinSize - core->pLast->nLength;
+        if( nAmnt > nLen )
+            nAmnt = nLen;
+        memcpy(
+            core->pLast->pData+core->pLast->nLength,
+            pData,
+            nAmnt
+           );
+        pData += nAmnt;
+        core->pLast->nLength += nAmnt;
+        nLen -= nAmnt;
+        core->nLength += nAmnt;
+    }
+
+    if( nLen > 0 )
+    {
+        Chunk *pNew = core->newChunk( nLen );
+        memcpy( pNew->pData, pData, nLen );
+        core->appendChunk( pNew );
+//              core->nLength += nLen;
+    }
 }
 
 void Bu::String::append( const char &cData )
 {
-        if( core->pLast && core->pLast->nLength < nMinSize )
-        {
-                _hardCopy();
-                core->pLast->pData[core->pLast->nLength] = cData;
-                ++core->pLast->nLength; ++core->nLength;
-//              pLast->pData[pLast->nLength] = (char)0;
-        }
-        else
-        {
-                append( &cData, 1 );
-        }
+    if( core->pLast && core->pLast->nLength < nMinSize )
+    {
+        _hardCopy();
+        core->pLast->pData[core->pLast->nLength] = cData;
+        ++core->pLast->nLength; ++core->nLength;
+//      pLast->pData[pLast->nLength] = (char)0;
+    }
+    else
+    {
+        append( &cData, 1 );
+    }
 }
 
 void Bu::String::append( const String & sData )
 {
-        append( sData.getStr(), 0, sData.getSize() );
+    append( sData.getStr(), 0, sData.getSize() );
 }
 
 void Bu::String::append( const String & sData, long nLen )
 {
-        append( sData.getStr(), 0, nLen );
+    append( sData.getStr(), 0, nLen );
 }
 
 void Bu::String::append( const String & sData, long nStart, long nLen )
 {
-        if( nLen < 0 )
-                nLen = sData.getSize() - nStart;
-        append( sData.getStr(), nStart, nLen );
+    if( nLen < 0 )
+        nLen = sData.getSize() - nStart;
+    append( sData.getStr(), nStart, nLen );
 }
 
 void Bu::String::append( const const_iterator &s )
 {
-        if( !s.isValid() )
-                return;
-        Chunk *pSrc = s.pChunk;
+    if( !s.isValid() )
+        return;
+    Chunk *pSrc = s.pChunk;
 
-        Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
-        memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
+    Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
+    memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
 
-        _hardCopy();
-        core->appendChunk( pNew );
+    _hardCopy();
+    core->appendChunk( pNew );
 
-        while( (pSrc = pSrc->pNext) )
-        {
-                core->appendChunk( core->copyChunk( pSrc ) );
-        }
+    while( (pSrc = pSrc->pNext) )
+    {
+        core->appendChunk( core->copyChunk( pSrc ) );
+    }
 }
 
 void Bu::String::append( const iterator &s )
 {
-        append( const_iterator( s ) );
+    append( const_iterator( s ) );
 }
 
 void Bu::String::append( const const_iterator &s, const const_iterator &e )
 {
-        if( !s.isValid() )
-                return;
-        if( !e.isValid() )
-        {
-                append( s );
-                return;
-        }
-        _hardCopy();
-        if( s.pChunk == e.pChunk )
-        {
-                // Simple case, they're the same chunk
-                Chunk *pNew = core->newChunk( e.iPos-s.iPos );
-                memcpy( pNew->pData, s.pChunk->pData+s.iPos, e.iPos-s.iPos );
-                core->appendChunk( pNew );
-        }
-        else
-        {
-                // A little trickier, scan the blocks...
-                Chunk *pSrc = s.pChunk;
-                Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
-                memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
-                core->appendChunk( pNew );
-
-                while( (pSrc = pSrc->pNext) != e.pChunk )
-                {
-                        core->appendChunk( core->copyChunk( pSrc ) );
-                }
-
-                pNew = core->newChunk( e.iPos );
-                memcpy( pNew->pData, pSrc->pData, e.iPos );
-                core->appendChunk( pNew );
-        }
+    if( !s.isValid() )
+        return;
+    if( !e.isValid() )
+    {
+        append( s );
+        return;
+    }
+    _hardCopy();
+    if( s.pChunk == e.pChunk )
+    {
+        // Simple case, they're the same chunk
+        Chunk *pNew = core->newChunk( e.iPos-s.iPos );
+        memcpy( pNew->pData, s.pChunk->pData+s.iPos, e.iPos-s.iPos );
+        core->appendChunk( pNew );
+    }
+    else
+    {
+        // A little trickier, scan the blocks...
+        Chunk *pSrc = s.pChunk;
+        Chunk *pNew = core->newChunk( pSrc->nLength-s.iPos );
+        memcpy( pNew->pData, pSrc->pData+s.iPos, pSrc->nLength-s.iPos );
+        core->appendChunk( pNew );
+
+        while( (pSrc = pSrc->pNext) != e.pChunk )
+        {
+            core->appendChunk( core->copyChunk( pSrc ) );
+        }
+
+        pNew = core->newChunk( e.iPos );
+        memcpy( pNew->pData, pSrc->pData, e.iPos );
+        core->appendChunk( pNew );
+    }
 }
 
 void Bu::String::prepend( const String & sData )
 {
-        prepend( sData.getStr(), sData.getSize() );
+    prepend( sData.getStr(), sData.getSize() );
 }
 
 void Bu::String::prepend( const char *pData )
 {
-        if( pData == NULL )
-                return;
+    if( pData == NULL )
+        return;
 
-        _hardCopy();
-        long nLen;
-        for( nLen = 0; pData[nLen] != (char)0; nLen++ ) { }
-        
-        Chunk *pNew = core->newChunk( nLen );
-        memcpy( pNew->pData, pData, nLen );
+    _hardCopy();
+    long nLen;
+    for( nLen = 0; pData[nLen] != (char)0; nLen++ ) { }
+    
+    Chunk *pNew = core->newChunk( nLen );
+    memcpy( pNew->pData, pData, nLen );
 
-        core->prependChunk( pNew );
+    core->prependChunk( pNew );
 }
 
 void Bu::String::prepend( const char *pData, long nLen )
 {
-        Chunk *pNew = core->newChunk( nLen );
-        
-        memcpy( pNew->pData, pData, nLen );
+    Chunk *pNew = core->newChunk( nLen );
+    
+    memcpy( pNew->pData, pData, nLen );
 
-        _hardCopy();
-        core->prependChunk( pNew );
+    _hardCopy();
+    core->prependChunk( pNew );
 }
 
 void Bu::String::prepend( const char c )
 {
-        prepend( &c, 1 );
+    prepend( &c, 1 );
 }
 
 void Bu::String::insert( long nPos, const char *pData, long nLen )
 {
-        if( nLen <= 0 )
-                return;
-        if( nPos <= 0 )
-        {
-                prepend( pData, nLen );
-        }
-        else if( nPos >= core->nLength )
-        {
-                append( pData, nLen );
-        }
-        else
-        {
-                // If we're going to flatten anyway, might as well for everyone
-                flatten();
-                _hardCopy();
-                Chunk *p1 = core->newChunk( nPos );
-                Chunk *p2 = core->newChunk( nLen );
-                Chunk *p3 = core->newChunk( core->nLength-nPos );
-                memcpy( p1->pData, core->pFirst->pData, nPos );
-                memcpy( p2->pData, pData, nLen );
-                memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
-                core->clear();
-                core->appendChunk( p1 );
-                core->appendChunk( p2 );
-                core->appendChunk( p3 );
-        }
+    if( nLen <= 0 )
+        return;
+    if( nPos <= 0 )
+    {
+        prepend( pData, nLen );
+    }
+    else if( nPos >= core->nLength )
+    {
+        append( pData, nLen );
+    }
+    else
+    {
+        // If we're going to flatten anyway, might as well for everyone
+        flatten();
+        _hardCopy();
+        Chunk *p1 = core->newChunk( nPos );
+        Chunk *p2 = core->newChunk( nLen );
+        Chunk *p3 = core->newChunk( core->nLength-nPos );
+        memcpy( p1->pData, core->pFirst->pData, nPos );
+        memcpy( p2->pData, pData, nLen );
+        memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
+        core->clear();
+        core->appendChunk( p1 );
+        core->appendChunk( p2 );
+        core->appendChunk( p3 );
+    }
 }
 
 void Bu::String::insert( long nPos, const String &str )
 {
-        if( nPos <= 0 )
-        {
-                prepend( str );
-        }
-        else if( nPos >= core->nLength )
-        {
-                append( str );
-        }
-        else
-        {
-                flatten();
-                _hardCopy();
-                Chunk *p1 = core->newChunk( nPos );
-                Chunk *p3 = core->newChunk( core->nLength-nPos );
-                memcpy( p1->pData, core->pFirst->pData, nPos );
-                memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
-                core->clear();
-                core->appendChunk( p1 );
-                for( Chunk *pChnk = str.core->pFirst; pChnk;
-                         pChnk = pChnk->pNext )
-                {
-                        core->appendChunk( core->copyChunk( pChnk ) );
-                }
-
-                core->appendChunk( p3 );
-        }
+    if( nPos <= 0 )
+    {
+        prepend( str );
+    }
+    else if( nPos >= core->nLength )
+    {
+        append( str );
+    }
+    else
+    {
+        flatten();
+        _hardCopy();
+        Chunk *p1 = core->newChunk( nPos );
+        Chunk *p3 = core->newChunk( core->nLength-nPos );
+        memcpy( p1->pData, core->pFirst->pData, nPos );
+        memcpy( p3->pData, core->pFirst->pData+nPos, core->nLength-nPos );
+        core->clear();
+        core->appendChunk( p1 );
+        for( Chunk *pChnk = str.core->pFirst; pChnk;
+             pChnk = pChnk->pNext )
+        {
+            core->appendChunk( core->copyChunk( pChnk ) );
+        }
+
+        core->appendChunk( p3 );
+    }
 }
 
 void Bu::String::insert( long nPos, const char *pData )
 {
-        insert( nPos, pData, strlen( pData ) );
+    insert( nPos, pData, strlen( pData ) );
 }
 
 void Bu::String::remove( long nPos, long nLen )
 {
-        if( nLen <= 0 || nPos < 0 || nPos >= core->nLength )
-                return;
-        if( nLen > core->nLength-nPos )
-                nLen = core->nLength-nPos;
-        flatten();
-        _hardCopy();
-        memmove( core->pFirst->pData+nPos, core->pFirst->pData+nPos+nLen, core->nLength-nPos-nLen+1 );
-        core->nLength -= nLen;
-        core->pFirst->nLength -= nLen;
+    if( nLen <= 0 || nPos < 0 || nPos >= core->nLength )
+        return;
+    if( nLen > core->nLength-nPos )
+        nLen = core->nLength-nPos;
+    flatten();
+    _hardCopy();
+    memmove( core->pFirst->pData+nPos, core->pFirst->pData+nPos+nLen, core->nLength-nPos-nLen+1 );
+    core->nLength -= nLen;
+    core->pFirst->nLength -= nLen;
 }
 
 void Bu::String::clear()
 {
-        _hardCopy();
-        core->clear();
+    _hardCopy();
+    core->clear();
 }
 
 Bu::String Bu::String::replace( const Bu::String &fnd,
-                const Bu::String &rep ) const
-{
-        String out;
-        const_iterator o = begin();
-        while( true )
-        {
-                const_iterator i = o.find( fnd, fnd.getSize() );
-                if( !i )
-                {
-                        out.append( o );
-                        return out;
-                }
-                else
-                {
-                        out.append( o, i );
-                        out.append( rep );
-                        o = i;
-                        o += fnd.getSize();
-                }
-        }
+        const Bu::String &rep ) const
+{
+    String out;
+    const_iterator o = begin();
+    while( true )
+    {
+        const_iterator i = o.find( fnd, fnd.getSize() );
+        if( !i )
+        {
+            out.append( o );
+            return out;
+        }
+        else
+        {
+            out.append( o, i );
+            out.append( rep );
+            o = i;
+            o += fnd.getSize();
+        }
+    }
 }
 
 void Bu::String::resize( long nNewSize )
 {
-        if( core->nLength == nNewSize )
-                return;
-        if( nNewSize < 0 )
-                nNewSize = 0;
+    if( core->nLength == nNewSize )
+        return;
+    if( nNewSize < 0 )
+        nNewSize = 0;
 
-        flatten();
-        _hardCopy();
+    flatten();
+    _hardCopy();
 
-        // TODO:  This is bad
+    // TODO:  This is bad
 
-        Chunk *pNew = core->newChunk( nNewSize );
-        long nNewLen = (nNewSize<core->nLength)?(nNewSize):(core->nLength);
-        if( core->nLength > 0 )
-        {
-                memcpy( pNew->pData, core->pFirst->pData, nNewLen );
-                delete[] core->pFirst->pData;
-                delete core->pFirst;
-        }
-        pNew->pData[nNewLen] = (char)0;
-        core->pFirst = core->pLast = pNew;
-        core->nLength = nNewSize;
+    Chunk *pNew = core->newChunk( nNewSize );
+    long nNewLen = (nNewSize<core->nLength)?(nNewSize):(core->nLength);
+    if( core->nLength > 0 )
+    {
+        memcpy( pNew->pData, core->pFirst->pData, nNewLen );
+        delete[] core->pFirst->pData;
+        delete core->pFirst;
+    }
+    pNew->pData[nNewLen] = (char)0;
+    core->pFirst = core->pLast = pNew;
+    core->nLength = nNewSize;
 }
 
 long Bu::String::getSize() const
 {
-        return core->nLength;
+    return core->nLength;
 }
 
 char *Bu::String::getStr()
 {
-        if( core->pFirst == NULL || core->nLength == 0 )
-                return (char *)"";
+    if( core->pFirst == NULL || core->nLength == 0 )
+        return (char *)"";
 
-        flatten();
-        _hardCopy();
-        core->pFirst->pData[core->nLength] = (char)0;
-        return core->pFirst->pData;
+    flatten();
+    _hardCopy();
+    core->pFirst->pData[core->nLength] = (char)0;
+    return core->pFirst->pData;
 }
 
 const char *Bu::String::getStr() const
 {
-        if( core->pFirst == NULL || core->nLength == 0 )
-                return (char *)"";
+    if( core->pFirst == NULL || core->nLength == 0 )
+        return (char *)"";
 
-        flatten();
-        core->pFirst->pData[core->nLength] = (char)0;
-        return core->pFirst->pData;
+    flatten();
+    core->pFirst->pData[core->nLength] = (char)0;
+    return core->pFirst->pData;
 }
 
 const char *Bu::String::getConstStr() const
 {
-        return getStr();
+    return getStr();
 }
 
 Bu::String Bu::String::getSubStrIdx( long iStart, long iSize ) const
 {
-        if( iStart < 0 )
-                iStart = 0;
-        if( iStart >= core->nLength )
-                return (const char[]){(char)0};
-        if( iSize < 0 )
-                iSize = core->nLength;
-        if( iStart+iSize > core->nLength )
-                iSize = core->nLength-iStart;
-        if( iSize == 0 )
-                return (const char[]){(char)0};
+    if( iStart < 0 )
+        iStart = 0;
+    if( iStart >= core->nLength )
+        return (const char[]){(char)0};
+    if( iSize < 0 )
+        iSize = core->nLength;
+    if( iStart+iSize > core->nLength )
+        iSize = core->nLength-iStart;
+    if( iSize == 0 )
+        return (const char[]){(char)0};
 
-        flatten();
-        String ret( core->pFirst->pData+iStart, iSize );
-        return ret;
+    flatten();
+    String ret( core->pFirst->pData+iStart, iSize );
+    return ret;
 }
 
 Bu::String Bu::String::getSubStr( const_iterator iBegin,
-                const_iterator iEnd ) const
-{
-        if( !iBegin.isValid() )
-                return String();
-        if( iBegin.pChunk == iEnd.pChunk )
-        {
-                return String( iBegin.pChunk->pData+iBegin.iPos,
-                        iEnd.iPos-iBegin.iPos );
-        }
-        else if( !iEnd.isValid() )
-        {
-                String ret;
-                ret.append(
-                        iBegin.pChunk->pData+iBegin.iPos,
-                        iBegin.pChunk->nLength-iBegin.iPos
-                        );
-                for( Chunk *pCur = iBegin.pChunk->pNext;
-                         pCur; pCur = pCur->pNext )
-                {
-                        ret.append( pCur->pData, pCur->nLength );
-                }
-                return ret;
-        }
-        else
-        {
-                String ret;
-                ret.append(
-                        iBegin.pChunk->pData+iBegin.iPos,
-                        iBegin.pChunk->nLength-iBegin.iPos
-                        );
-                for( Chunk *pCur = iBegin.pChunk->pNext;
-                         pCur != iEnd.pChunk; pCur = pCur->pNext )
-                {
-                        ret.append( pCur->pData, pCur->nLength );
-                }
-                ret.append(
-                        iEnd.pChunk->pData,
-                        iEnd.iPos
-                        );
-                return ret;
-        }
+        const_iterator iEnd ) const
+{
+    if( !iBegin.isValid() )
+        return String();
+    if( iBegin.pChunk == iEnd.pChunk )
+    {
+        return String( iBegin.pChunk->pData+iBegin.iPos,
+            iEnd.iPos-iBegin.iPos );
+    }
+    else if( !iEnd.isValid() )
+    {
+        String ret;
+        ret.append(
+            iBegin.pChunk->pData+iBegin.iPos,
+            iBegin.pChunk->nLength-iBegin.iPos
+            );
+        for( Chunk *pCur = iBegin.pChunk->pNext;
+             pCur; pCur = pCur->pNext )
+        {
+            ret.append( pCur->pData, pCur->nLength );
+        }
+        return ret;
+    }
+    else
+    {
+        String ret;
+        ret.append(
+            iBegin.pChunk->pData+iBegin.iPos,
+            iBegin.pChunk->nLength-iBegin.iPos
+            );
+        for( Chunk *pCur = iBegin.pChunk->pNext;
+             pCur != iEnd.pChunk; pCur = pCur->pNext )
+        {
+            ret.append( pCur->pData, pCur->nLength );
+        }
+        ret.append(
+            iEnd.pChunk->pData,
+            iEnd.iPos
+            );
+        return ret;
+    }
 }
 
 Bu::StringList Bu::String::split( const char c ) const
 {
-        Bu::StringList ret;
-        const_iterator l, r;
-        l = begin();
-        for(r=l; l;)
-        {
-                for( r = l; r && r != c; r++ ) { }
-                ret.append( String( l, r ) );
-                l = r;
-                l++;
-        }
-        return ret;
+    Bu::StringList ret;
+    const_iterator l, r;
+    l = begin();
+    for(r=l; l;)
+    {
+        for( r = l; r && r != c; r++ ) { }
+        ret.append( String( l, r ) );
+        l = r;
+        l++;
+    }
+    return ret;
 }
 
 Bu::String &Bu::String::operator+=( const char *pData )
 {
-        append( pData );
+    append( pData );
 
-        return (*this);
+    return (*this);
 }
 
 Bu::String &Bu::String::operator+=( const Bu::String &rSrc )
 {
-        append( rSrc );
+    append( rSrc );
 
-        return (*this);
+    return (*this);
 }
 
 Bu::String &Bu::String::operator+=( const Bu::String::const_iterator &i )
 {
-        append( i, i+1 );
+    append( i, i+1 );
 
-        return (*this);
+    return (*this);
 }
 
 Bu::String &Bu::String::operator+=( const char cData )
 {
-        if( core->pLast && core->pLast->nLength < nMinSize )
-        {
-                _hardCopy();
-                core->pLast->pData[core->pLast->nLength] = cData;
-                ++core->pLast->nLength; ++core->nLength;
-//              pLast->pData[pLast->nLength] = (char)0;
-        }
-        else
-        {
-                append( &cData, 1 );
-        }
-        //append( pData );
+    if( core->pLast && core->pLast->nLength < nMinSize )
+    {
+        _hardCopy();
+        core->pLast->pData[core->pLast->nLength] = cData;
+        ++core->pLast->nLength; ++core->nLength;
+//      pLast->pData[pLast->nLength] = (char)0;
+    }
+    else
+    {
+        append( &cData, 1 );
+    }
+    //append( pData );
 
-        return (*this);
+    return (*this);
 }
 
 Bu::String &Bu::String::operator=( const char *pData )
 {
-        set( pData );
+    set( pData );
 
-        return (*this);
+    return (*this);
 }
 
 Bu::String Bu::String::operator+( const Bu::String &rRight ) const
 {
-        String ret( *this );
-        ret.append( rRight );
-        return ret;
+    String ret( *this );
+    ret.append( rRight );
+    return ret;
 }
 
 Bu::String Bu::String::operator+( const char *pRight ) const
 {
-        String ret( *this );
-        ret.append( pRight );
-        return ret;
+    String ret( *this );
+    ret.append( pRight );
+    return ret;
 }
 
 Bu::String Bu::String::operator+( char *pRight ) const
 {
-        String ret( *this );
-        ret.append( pRight );
-        return ret;
+    String ret( *this );
+    ret.append( pRight );
+    return ret;
 }
 
 void Bu::String::set( const char *pData )
 {
-        clear();
-        append( pData );
+    clear();
+    append( pData );
 }
 
 void Bu::String::set( const char *pData, long nSize )
 {
-        clear();
-        append( pData, nSize );
+    clear();
+    append( pData, nSize );
 }
 
 void Bu::String::set( const char *pData, long nStart, long nSize )
 {
-        clear();
-        append( pData, nStart, nSize );
+    clear();
+    append( pData, nStart, nSize );
 }
 
 void Bu::String::set( const String &rData )
 {
-        clear();
-        append( rData );
+    clear();
+    append( rData );
 }
 
 void Bu::String::set( const String &rData, long nSize )
 {
-        clear();
-        append( rData, nSize );
+    clear();
+    append( rData, nSize );
 }
 
 void Bu::String::set( const String &rData, long nStart, long nSize )
 {
-        clear();
-        append( rData, nStart, nSize );
+    clear();
+    append( rData, nStart, nSize );
 }
 
 void Bu::String::set( const_iterator s )
 {
-        clear();
-        append( s );
+    clear();
+    append( s );
 }
 
 void Bu::String::set( const_iterator s, const_iterator e )
 {
-        clear();
-        append( s, e );
+    clear();
+    append( s, e );
 }
 
 void Bu::String::setSize( long iSize )
 {
-        _hardCopy();
-        core->clear();
-        core->appendChunk( core->newChunk( iSize ) );
+    _hardCopy();
+    core->clear();
+    core->appendChunk( core->newChunk( iSize ) );
 }
 
 bool Bu::String::operator==( const char *pData ) const
 {
-        if( core->pFirst == NULL || core->nLength == 0 ) {
-                if( pData == NULL )
-                        return true;
-                if( pData[0] == (char)0 )
-                        return true;
-                return false;
-        }
-
-        flatten();
-        core->pFirst->pData[core->nLength] = (char)0;
-        const char *a = pData;
-        char *b = core->pFirst->pData;
-        for( long j = 0; *a!=(char)0 || *b!=(char)0; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return false;
-                if( *a == (char)0 && j < core->nLength )
-                        return false;
-        }
-
-        return true;
+    if( core->pFirst == NULL || core->nLength == 0 ) {
+        if( pData == NULL )
+            return true;
+        if( pData[0] == (char)0 )
+            return true;
+        return false;
+    }
+
+    flatten();
+    core->pFirst->pData[core->nLength] = (char)0;
+    const char *a = pData;
+    char *b = core->pFirst->pData;
+    for( long j = 0; *a!=(char)0 || *b!=(char)0; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return false;
+        if( *a == (char)0 && j < core->nLength )
+            return false;
+    }
+
+    return true;
 }
 
 bool Bu::String::operator==( const String &pData ) const
 {
-        if( core == pData.core )
-                return true;
-        if( core->pFirst == pData.core->pFirst )
-                return true;
-        if( (core->nLength == 0 && pData.core->nLength == 0) ) 
-                return true;
-        if( core->nLength != pData.core->nLength )
-                return false;
-        if( pData.core->pFirst == NULL || core->pFirst == NULL )
-                return false;
-
-        flatten();
-        pData.flatten();
-        const char *a = pData.core->pFirst->pData;
-        char *b = core->pFirst->pData;
-        for( long j = 0; j < core->nLength; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return false;
-        }
-
-        return true;
+    if( core == pData.core )
+        return true;
+    if( core->pFirst == pData.core->pFirst )
+        return true;
+    if( (core->nLength == 0 && pData.core->nLength == 0) ) 
+        return true;
+    if( core->nLength != pData.core->nLength )
+        return false;
+    if( pData.core->pFirst == NULL || core->pFirst == NULL )
+        return false;
+
+    flatten();
+    pData.flatten();
+    const char *a = pData.core->pFirst->pData;
+    char *b = core->pFirst->pData;
+    for( long j = 0; j < core->nLength; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return false;
+    }
+
+    return true;
 }
 
 bool Bu::String::operator!=(const char *pData ) const
 {
-        return !(*this == pData);
+    return !(*this == pData);
 }
 
 bool Bu::String::operator!=(const String &pData ) const
 {
-        return !(*this == pData);
+    return !(*this == pData);
 }
 
 bool Bu::String::operator<(const String &pData ) const
 {
-        flatten();
-        pData.flatten();
+    flatten();
+    pData.flatten();
 
-        const char *a = core->pFirst->pData;
-        char *b = pData.core->pFirst->pData;
-        for( long j = 0; j < core->nLength; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return *a < *b;
-        }
+    const char *a = core->pFirst->pData;
+    char *b = pData.core->pFirst->pData;
+    for( long j = 0; j < core->nLength; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return *a < *b;
+    }
 
-        return false;
+    return false;
 }
 
 bool Bu::String::operator<=(const String &pData ) const
 {
-        flatten();
-        pData.flatten();
+    flatten();
+    pData.flatten();
 
-        const char *a = core->pFirst->pData;
-        char *b = pData.core->pFirst->pData;
-        for( long j = 0; j < core->nLength; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return *a < *b;
-        }
+    const char *a = core->pFirst->pData;
+    char *b = pData.core->pFirst->pData;
+    for( long j = 0; j < core->nLength; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return *a < *b;
+    }
 
-        return true;
+    return true;
 }
 
 bool Bu::String::operator>(const String &pData ) const
 {
-        flatten();
-        pData.flatten();
+    flatten();
+    pData.flatten();
 
-        const char *a = core->pFirst->pData;
-        char *b = pData.core->pFirst->pData;
-        for( long j = 0; j < core->nLength; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return *a > *b;
-        }
+    const char *a = core->pFirst->pData;
+    char *b = pData.core->pFirst->pData;
+    for( long j = 0; j < core->nLength; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return *a > *b;
+    }
 
-        return false;
+    return false;
 }
 
 bool Bu::String::operator>=(const String &pData ) const
 {
-        flatten();
-        pData.flatten();
+    flatten();
+    pData.flatten();
 
-        const char *a = core->pFirst->pData;
-        char *b = pData.core->pFirst->pData;
-        for( long j = 0; j < core->nLength; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return *a > *b;
-        }
+    const char *a = core->pFirst->pData;
+    char *b = pData.core->pFirst->pData;
+    for( long j = 0; j < core->nLength; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return *a > *b;
+    }
 
-        return true;
+    return true;
 }
 
 char &Bu::String::operator[]( long nIndex )
 {
-        if( nIndex < 0 || nIndex >= core->nLength )
-                throw Bu::ExceptionBase("Index out of range.");
-        flatten();
-        _hardCopy();
+    if( nIndex < 0 || nIndex >= core->nLength )
+        throw Bu::ExceptionBase("Index out of range.");
+    flatten();
+    _hardCopy();
 
-        return core->pFirst->pData[nIndex];
+    return core->pFirst->pData[nIndex];
 }
 
 const char &Bu::String::operator[]( long nIndex ) const
 {
-        if( nIndex < 0 || nIndex >= core->nLength )
-                throw Bu::ExceptionBase("Index out of range.");
-        flatten();
+    if( nIndex < 0 || nIndex >= core->nLength )
+        throw Bu::ExceptionBase("Index out of range.");
+    flatten();
 
-        return core->pFirst->pData[nIndex];
+    return core->pFirst->pData[nIndex];
 }
 
 bool Bu::String::isSet() const
 {
-        return (core->pFirst != NULL);
+    return (core->pFirst != NULL);
 }
 
 bool Bu::String::compareSub( const char *pData, long nIndex, long nLen ) const
 {
-        if( core->pFirst == NULL || core->nLength == 0 ) {
-                if( pData == NULL )
-                        return true;
-                if( nLen == 0 )
-                        return true;
-                if( pData[0] == (char)0 )
-                        return true;
-                return false;
-        }
-        if( nIndex+nLen > core->nLength )
-                return false;
-
-        flatten();
-        core->pFirst->pData[core->nLength] = (char)0;
-        const char *a = pData;
-        char *b = core->pFirst->pData+nIndex;
-        for( long j = 0; j < nLen; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return false;
-                if( *a == (char)0 && j < core->nLength )
-                        return false;
-        }
-
-        return true;
+    if( core->pFirst == NULL || core->nLength == 0 ) {
+        if( pData == NULL )
+            return true;
+        if( nLen == 0 )
+            return true;
+        if( pData[0] == (char)0 )
+            return true;
+        return false;
+    }
+    if( nIndex+nLen > core->nLength )
+        return false;
+
+    flatten();
+    core->pFirst->pData[core->nLength] = (char)0;
+    const char *a = pData;
+    char *b = core->pFirst->pData+nIndex;
+    for( long j = 0; j < nLen; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return false;
+        if( *a == (char)0 && j < core->nLength )
+            return false;
+    }
+
+    return true;
 }
 
 bool Bu::String::compareSub( const String &rData, long nIndex, long nLen ) const
 {
-        if( core->pFirst == NULL || core->nLength == 0 || rData.core->pFirst == NULL || rData.core->nLength == 0 ) 
-                return false;
-        if( nLen < 0 )
-                nLen = rData.core->nLength;
-        if( nIndex+nLen > core->nLength )
-                return false;
+    if( core->pFirst == NULL || core->nLength == 0 || rData.core->pFirst == NULL || rData.core->nLength == 0 ) 
+        return false;
+    if( nLen < 0 )
+        nLen = rData.core->nLength;
+    if( nIndex+nLen > core->nLength )
+        return false;
 
-        flatten();
-        rData.flatten();
-        const char *a = rData.core->pFirst->pData;
-        char *b = core->pFirst->pData + nIndex;
-        for( long j = 0; j < nLen; j++, a++, b++ )
-        {
-                if( *a != *b )
-                        return false;
-        }
+    flatten();
+    rData.flatten();
+    const char *a = rData.core->pFirst->pData;
+    char *b = core->pFirst->pData + nIndex;
+    for( long j = 0; j < nLen; j++, a++, b++ )
+    {
+        if( *a != *b )
+            return false;
+    }
 
-        return true;
+    return true;
 }
 
 bool Bu::String::isWS( long nIndex ) const
 {
-        flatten();
+    flatten();
 
-        return core->pFirst->pData[nIndex]==' ' || core->pFirst->pData[nIndex]=='\t'
-                || core->pFirst->pData[nIndex]=='\r' || core->pFirst->pData[nIndex]=='\n';
+    return core->pFirst->pData[nIndex]==' ' || core->pFirst->pData[nIndex]=='\t'
+        || core->pFirst->pData[nIndex]=='\r' || core->pFirst->pData[nIndex]=='\n';
 }
 
 bool Bu::String::isAlpha( long nIndex ) const
 {
-        flatten();
+    flatten();
 
-        return (core->pFirst->pData[nIndex] >= 'a' && core->pFirst->pData[nIndex] <= 'z')
-                || (core->pFirst->pData[nIndex] >= 'A' && core->pFirst->pData[nIndex] <= 'Z');
+    return (core->pFirst->pData[nIndex] >= 'a' && core->pFirst->pData[nIndex] <= 'z')
+        || (core->pFirst->pData[nIndex] >= 'A' && core->pFirst->pData[nIndex] <= 'Z');
 }
 
 Bu::String Bu::String::toLower() const
 {
-        Bu::String sRet = *this;
+    Bu::String sRet = *this;
 
-        sRet.flatten();
-        sRet._hardCopy();
+    sRet.flatten();
+    sRet._hardCopy();
 
-        for( long j = 0; j < sRet.core->nLength; j++ )
-        {
-                if( sRet.core->pFirst->pData[j] >= 'A' &&
-                        sRet.core->pFirst->pData[j] <= 'Z' )
-                        sRet.core->pFirst->pData[j] -= 'A'-'a';
-        }
+    for( long j = 0; j < sRet.core->nLength; j++ )
+    {
+        if( sRet.core->pFirst->pData[j] >= 'A' &&
+            sRet.core->pFirst->pData[j] <= 'Z' )
+            sRet.core->pFirst->pData[j] -= 'A'-'a';
+    }
 
-        return sRet;
+    return sRet;
 }
 
 Bu::String Bu::String::toUpper() const
 {
-        Bu::String sRet = *this;
+    Bu::String sRet = *this;
 
-        sRet.flatten();
-        sRet._hardCopy();
+    sRet.flatten();
+    sRet._hardCopy();
 
-        for( long j = 0; j < sRet.core->nLength; j++ )
-        {
-                if( sRet.core->pFirst->pData[j] >= 'a' &&
-                        sRet.core->pFirst->pData[j] <= 'z' )
-                        sRet.core->pFirst->pData[j] += 'A'-'a';
-        }
-        
-        return sRet;
+    for( long j = 0; j < sRet.core->nLength; j++ )
+    {
+        if( sRet.core->pFirst->pData[j] >= 'a' &&
+            sRet.core->pFirst->pData[j] <= 'z' )
+            sRet.core->pFirst->pData[j] += 'A'-'a';
+    }
+    
+    return sRet;
 }
 
 Bu::String::const_iterator Bu::String::find( const char cChar,
-                Bu::String::const_iterator iStart ) const
+        Bu::String::const_iterator iStart ) const
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( cChar == *iStart )
-                        return iStart;
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( cChar == *iStart )
+            return iStart;
+    }
+    return end();
 }
 
 Bu::String::const_iterator Bu::String::find( const char *sText, int nLen,
-                Bu::String::const_iterator iStart ) const
+        Bu::String::const_iterator iStart ) const
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( sText, nLen ) )
-                        return iStart;
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( sText, nLen ) )
+            return iStart;
+    }
+    return end();
 }
 
 Bu::String::const_iterator Bu::String::find( const String &rStr,
-                Bu::String::const_iterator iStart ) const
+        Bu::String::const_iterator iStart ) const
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( rStr ) )
-                        return iStart;
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( rStr ) )
+            return iStart;
+    }
+    return end();
 }
 
 Bu::String::const_iterator Bu::String::find( const String &rStr, int nLen,
-                Bu::String::const_iterator iStart ) const
+        Bu::String::const_iterator iStart ) const
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( rStr, nLen ) )
-                        return iStart;
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( rStr, nLen ) )
+            return iStart;
+    }
+    return end();
 }
 
 Bu::String::iterator Bu::String::find( const char cChar,
-                Bu::String::const_iterator iStart )
+        Bu::String::const_iterator iStart )
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( cChar == *iStart )
-                        return iterator( iStart.pChunk, iStart.iPos );
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( cChar == *iStart )
+            return iterator( iStart.pChunk, iStart.iPos );
+    }
+    return end();
 }
 
 Bu::String::iterator Bu::String::find( const char *sText, int nLen,
-                Bu::String::const_iterator iStart )
+        Bu::String::const_iterator iStart )
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( sText, nLen ) )
-                        return iterator( iStart.pChunk, iStart.iPos );
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( sText, nLen ) )
+            return iterator( iStart.pChunk, iStart.iPos );
+    }
+    return end();
 }
 
 Bu::String::iterator Bu::String::find( const String &rStr,
-                Bu::String::const_iterator iStart )
+        Bu::String::const_iterator iStart )
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( rStr ) )
-                        return iterator( iStart.pChunk, iStart.iPos );
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( rStr ) )
+            return iterator( iStart.pChunk, iStart.iPos );
+    }
+    return end();
 }
 
 Bu::String::iterator Bu::String::find( const String &rStr, int nLen,
-                Bu::String::const_iterator iStart )
+        Bu::String::const_iterator iStart )
 {
-        if( !iStart ) iStart = begin();
-        for( ; iStart; iStart++ )
-        {
-                if( iStart.compare( rStr, nLen ) )
-                        return iterator( iStart.pChunk, iStart.iPos );
-        }
-        return end();
+    if( !iStart ) iStart = begin();
+    for( ; iStart; iStart++ )
+    {
+        if( iStart.compare( rStr, nLen ) )
+            return iterator( iStart.pChunk, iStart.iPos );
+    }
+    return end();
 }
 
 long Bu::String::findIdx( const char cChar, long iStart ) const
 {
-        flatten();
-        for( long j = iStart; j < core->pFirst->nLength; j++ )
-        {
-                if( core->pFirst->pData[j] == cChar )
-                        return j;
-        }
-        return -1;
+    flatten();
+    for( long j = iStart; j < core->pFirst->nLength; j++ )
+    {
+        if( core->pFirst->pData[j] == cChar )
+            return j;
+    }
+    return -1;
 }
 
 long Bu::String::findIdx( const char *sText, long iStart ) const
 {
-        long nTLen = strlen( sText );
-        flatten();
-        for( long j = iStart; j < core->pFirst->nLength-nTLen; j++ )
-        {
-                if( !strncmp( sText, core->pFirst->pData+j, nTLen ) )
-                        return j;
-        }
-        return -1;
+    long nTLen = strlen( sText );
+    flatten();
+    for( long j = iStart; j < core->pFirst->nLength-nTLen; j++ )
+    {
+        if( !strncmp( sText, core->pFirst->pData+j, nTLen ) )
+            return j;
+    }
+    return -1;
 }
 
 long Bu::String::rfindIdx( const char *sText ) const
 {
-        long nTLen = strlen( sText );
-        flatten();
-        for( long j = core->pFirst->nLength-nTLen-1; j >= 0; j-- )
-        {
-                if( !strncmp( sText, core->pFirst->pData+j, nTLen ) )
-                        return j;
-        }
-        return -1;
+    long nTLen = strlen( sText );
+    flatten();
+    for( long j = core->pFirst->nLength-nTLen-1; j >= 0; j-- )
+    {
+        if( !strncmp( sText, core->pFirst->pData+j, nTLen ) )
+            return j;
+    }
+    return -1;
 }
 
 void Bu::String::trimFront( long nAmnt )
 {
-        long nNewLen = core->nLength - nAmnt;
-        flatten();
-        Chunk *pNew = core->newChunk( nNewLen );
-        memcpy( pNew->pData, core->pFirst->pData+nAmnt, nNewLen );
-        _hardCopy();
-        core->clear();
-        core->appendChunk( pNew );
+    long nNewLen = core->nLength - nAmnt;
+    flatten();
+    Chunk *pNew = core->newChunk( nNewLen );
+    memcpy( pNew->pData, core->pFirst->pData+nAmnt, nNewLen );
+    _hardCopy();
+    core->clear();
+    core->appendChunk( pNew );
 }
 /*
 void Bu::String::trimBack( char c )
 {
-        if( core->pFirst == NULL || core->nLength == 0 )
-                return;
-        flatten();
-        for( ; core->pFirst->nLength > 0 &&
-                core->pFirst->pData[core->pFirst->nLength-1] == c;
-                core->pFirst->nLength--, core->nLength-- ) { }
+    if( core->pFirst == NULL || core->nLength == 0 )
+        return;
+    flatten();
+    for( ; core->pFirst->nLength > 0 &&
+        core->pFirst->pData[core->pFirst->nLength-1] == c;
+        core->pFirst->nLength--, core->nLength-- ) { }
 }
 */
 void Bu::String::trimBack( long iAmnt )
 {
-        if( iAmnt < 0 )
-                return;
-        if( core->nLength - iAmnt < 0 )
-        {
-                clear();
-                return;
-        }
-        if( core->pFirst == NULL || core->nLength == 0 )
-                return;
+    if( iAmnt < 0 )
+        return;
+    if( core->nLength - iAmnt < 0 )
+    {
+        clear();
+        return;
+    }
+    if( core->pFirst == NULL || core->nLength == 0 )
+        return;
 
-        flatten();
-        core->pFirst->nLength -= iAmnt;
-        core->nLength -= iAmnt;
+    flatten();
+    core->pFirst->nLength -= iAmnt;
+    core->nLength -= iAmnt;
 }
 
 Bu::String Bu::String::trimWhitespace() const
 {
-        if( core->nLength == 0 )
-                return "";
-        const_iterator i = begin();
-        for( ; i && (*i == ' ' || *i == '\t' || *i == '\n' || *i == '\r'); i++ ) { }
-        if( !i )
-                return "";
-
-        const_iterator e = i;
-        for( ; e; e++ )
-        {
-                if( *e == ' ' || *e == '\t' || *e == '\n' || *e == '\r' )
-                {
-                        const_iterator t = e;
-                        for( ; t && (*t == ' ' || *t == '\t' || *t == '\n' || *t == '\r'); t++ ) { }
-                        if( t )
-                        {
-                                e = t;
-                        }
-                        else
-                        {
-                                break;
-                        }
-                }
-        }
-
-        return Bu::String( i, e );
+    if( core->nLength == 0 )
+        return "";
+    const_iterator i = begin();
+    for( ; i && (*i == ' ' || *i == '\t' || *i == '\n' || *i == '\r'); i++ ) { }
+    if( !i )
+        return "";
+
+    const_iterator e = i;
+    for( ; e; e++ )
+    {
+        if( *e == ' ' || *e == '\t' || *e == '\n' || *e == '\r' )
+        {
+            const_iterator t = e;
+            for( ; t && (*t == ' ' || *t == '\t' || *t == '\n' || *t == '\r'); t++ ) { }
+            if( t )
+            {
+                e = t;
+            }
+            else
+            {
+                break;
+            }
+        }
+    }
+
+    return Bu::String( i, e );
 }
 
 Bu::String::iterator Bu::String::begin()
 {
-        if( core->nLength == 0 )
-                return iterator( NULL, 0 );
-        return iterator( core->pFirst, 0 );
+    if( core->nLength == 0 )
+        return iterator( NULL, 0 );
+    return iterator( core->pFirst, 0 );
 }
 
 Bu::String::const_iterator Bu::String::begin() const
 {
-        if( core->nLength == 0 )
-                return const_iterator( NULL, 0 );
-        return iterator( core->pFirst, 0 );
+    if( core->nLength == 0 )
+        return const_iterator( NULL, 0 );
+    return iterator( core->pFirst, 0 );
 }
 
 Bu::String::iterator Bu::String::end()
 {
-        return iterator( NULL, 0 );
+    return iterator( NULL, 0 );
 }
 
 Bu::String::const_iterator Bu::String::end() const
 {
-        return const_iterator( NULL, 0 );
+    return const_iterator( NULL, 0 );
 }
 
 bool Bu::String::isEmpty() const
 {
-        if( core->nLength == 0 )
-                return true;
-        return false;
+    if( core->nLength == 0 )
+        return true;
+    return false;
 }
 
 void Bu::String::flatten() const
 {
-        if( isFlat() )
-                return;
+    if( isFlat() )
+        return;
 
-        if( core->pFirst == NULL || core->nLength == 0 )
-                return;
+    if( core->pFirst == NULL || core->nLength == 0 )
+        return;
 
-        Chunk *pNew = core->newChunk( core->nLength );
-        char *pos = pNew->pData;
-        Chunk *i = core->pFirst;
-        for(;;)
-        {
-                memcpy( pos, i->pData, i->nLength );
-                pos += i->nLength;
-                i = i->pNext;
-                if( i == NULL )
-                        break;
-        }
-        core->clear();
+    Chunk *pNew = core->newChunk( core->nLength );
+    char *pos = pNew->pData;
+    Chunk *i = core->pFirst;
+    for(;;)
+    {
+        memcpy( pos, i->pData, i->nLength );
+        pos += i->nLength;
+        i = i->pNext;
+        if( i == NULL )
+            break;
+    }
+    core->clear();
 
-        core->pLast = core->pFirst = pNew;
-        core->nLength = pNew->nLength;
+    core->pLast = core->pFirst = pNew;
+    core->nLength = pNew->nLength;
 }
 
 bool Bu::String::isFlat() const
 {
-        return (core->pFirst == core->pLast);
+    return (core->pFirst == core->pLast);
 }
 
 //
@@ -1229,98 +1229,98 @@ bool Bu::String::isFlat() const
 //
 
 Bu::String::FormatProxy::FormatProxy( const String &rFmt,
-                String::FormatProxyEndAction *pAct ) :
-        rFmt( rFmt ),
-        pAct( pAct ),
-        bOpen( true )
+        String::FormatProxyEndAction *pAct ) :
+    rFmt( rFmt ),
+    pAct( pAct ),
+    bOpen( true )
 {
 }
 
 Bu::String::FormatProxy::~FormatProxy()
 {
-        if( pAct && bOpen )
-                end();
+    if( pAct && bOpen )
+        end();
 
-        delete pAct;
+    delete pAct;
 }
 
 Bu::String Bu::String::FormatProxy::end() const
 {
-        int iCount = lArgs.getSize();
-        ArgList::const_iterator *aArg =
-                new ArgList::const_iterator[iCount];
-        {
-                int j = 0;
-                for( ArgList::const_iterator i = lArgs.begin();
-                         i; i++, j++ )
-                {
-                        aArg[j] = i;
-                }
-        }
-        Bu::MemBuf mbOut;
-        Bu::Formatter f( mbOut );
-        for( String::const_iterator s = rFmt.begin(); s; )
-        {
-                if( *s == '%' )
-                {
-                        s++;
-                        if( *s == '%' )
-                                f << *s;
-                        else
-                        {
-                                String sNum;
-                                if( *s == '{' )
-                                {
-                                        s++;
-                                        while( s && *s >= '0' && *s <= '9' )
-                                        {
-                                                sNum += *s;
-                                                s++;
-                                        }
-                                        if( !s || *s != '}' )
-                                        {
-                                                delete[] aArg;
-                                                throw Bu::ExceptionBase(
-                                                        "Argument started with a '{' but terminated "
-                                                        "with a '%c' instead of '}'.", *s );
-                                        }
-                                        s++;
-                                }
-                                else
-                                {
-                                        while( s && *s >= '0' && *s <= '9' )
-                                        {
-                                                sNum += *s;
-                                                s++;
-                                        }
-                                }
-                                int iIndex = strtol( sNum.getStr(), 0, 10 )-1;
-                                if( iIndex < 0 || iIndex >= iCount )
-                                {
-                                        delete[] aArg;
-                                        throw Bu::ExceptionBase(
-                                                "Argument index %d is outside of "
-                                                "valid range (1-%d).", iIndex+1, iCount
-                                                );
-                                }
+    int iCount = lArgs.getSize();
+    ArgList::const_iterator *aArg =
+        new ArgList::const_iterator[iCount];
+    {
+        int j = 0;
+        for( ArgList::const_iterator i = lArgs.begin();
+             i; i++, j++ )
+        {
+            aArg[j] = i;
+        }
+    }
+    Bu::MemBuf mbOut;
+    Bu::Formatter f( mbOut );
+    for( String::const_iterator s = rFmt.begin(); s; )
+    {
+        if( *s == '%' )
+        {
+            s++;
+            if( *s == '%' )
+                f << *s;
+            else
+            {
+                String sNum;
+                if( *s == '{' )
+                {
+                    s++;
+                    while( s && *s >= '0' && *s <= '9' )
+                    {
+                        sNum += *s;
+                        s++;
+                    }
+                    if( !s || *s != '}' )
+                    {
+                        delete[] aArg;
+                        throw Bu::ExceptionBase(
+                            "Argument started with a '{' but terminated "
+                            "with a '%c' instead of '}'.", *s );
+                    }
+                    s++;
+                }
+                else
+                {
+                    while( s && *s >= '0' && *s <= '9' )
+                    {
+                        sNum += *s;
+                        s++;
+                    }
+                }
+                int iIndex = strtol( sNum.getStr(), 0, 10 )-1;
+                if( iIndex < 0 || iIndex >= iCount )
+                {
+                    delete[] aArg;
+                    throw Bu::ExceptionBase(
+                        "Argument index %d is outside of "
+                        "valid range (1-%d).", iIndex+1, iCount
+                        );
+                }
 
-                                f << (*aArg[iIndex]).format << (*aArg[iIndex]).value;
-                                continue;
-                        }
-                }
-                else
-                {
-                        f << *s;
-                }
-                s++;
-        }
-        
-        bOpen = false;
-        delete[] aArg;
+                f << (*aArg[iIndex]).format << (*aArg[iIndex]).value;
+                continue;
+            }
+        }
+        else
+        {
+            f << *s;
+        }
+        s++;
+    }
+    
+    bOpen = false;
+    delete[] aArg;
 
-        if( pAct )
-                (*pAct)( mbOut.getString() );
-        return mbOut.getString();
+    if( pAct )
+        (*pAct)( mbOut.getString() );
+    return mbOut.getString();
 }
 
 
@@ -1371,131 +1371,131 @@ Bu::String Bu::String::FormatProxy::end() const
 
 template<> uint32_t Bu::__calcHashCode<Bu::String>( const Bu::String &k )
 {
-        long j, sz = k.getSize();
-        const char *s = k.getStr();
+    long j, sz = k.getSize();
+    const char *s = k.getStr();
 
-        long nPos = 0;
-        for( j = 0; j < sz; j++, s++ )
-        {
-                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
-        }
+    long nPos = 0;
+    for( j = 0; j < sz; j++, s++ )
+    {
+        nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
+    }
 
-        return nPos;
+    return nPos;
 }
 
 template<> bool Bu::__cmpHashKeys<Bu::String>(
-                const Bu::String &a, const Bu::String &b )
+        const Bu::String &a, const Bu::String &b )
 {
-        return a == b;
+    return a == b;
 }
 
 template<> void Bu::__tracer_format<Bu::String>( const Bu::String &v )
 {
-        printf("(%ld)\"%s\"", v.getSize(), v.getStr() );
+    printf("(%ld)\"%s\"", v.getSize(), v.getStr() );
 }
 
 bool &Bu::operator<<( bool &dst, const Bu::String &sIn )
 {
-        if( sIn == "true" || sIn == "yes" || sIn == "t" )
-                dst = true;
-        else
-                dst = false;
+    if( sIn == "true" || sIn == "yes" || sIn == "t" )
+        dst = true;
+    else
+        dst = false;
 
-        return dst;
+    return dst;
 }
 
 uint8_t &Bu::operator<<( uint8_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%hhu", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%hhu", &dst );
+    return dst;
 }
 
 int8_t &Bu::operator<<( int8_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%hhd", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%hhd", &dst );
+    return dst;
 }
 
 char &Bu::operator<<( char &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%hhd", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%hhd", &dst );
+    return dst;
 }
 
 uint16_t &Bu::operator<<( uint16_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%hu", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%hu", &dst );
+    return dst;
 }
 
 int16_t &Bu::operator<<( int16_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%hd", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%hd", &dst );
+    return dst;
 }
 
 uint32_t &Bu::operator<<( uint32_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%u", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%u", &dst );
+    return dst;
 }
 
 int32_t &Bu::operator<<( int32_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%d", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%d", &dst );
+    return dst;
 }
 
 uint64_t &Bu::operator<<( uint64_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%llu", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%llu", &dst );
+    return dst;
 }
 
 int64_t &Bu::operator<<( int64_t &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%lld", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%lld", &dst );
+    return dst;
 }
 
 float &Bu::operator<<( float &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%f", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%f", &dst );
+    return dst;
 }
 
 double &Bu::operator<<( double &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%lf", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%lf", &dst );
+    return dst;
 }
 
 long double &Bu::operator<<( long double &dst, const Bu::String &sIn )
 {
-        sscanf( sIn.getStr(), "%Lf", &dst );
-        return dst;
+    sscanf( sIn.getStr(), "%Lf", &dst );
+    return dst;
 }
 
 Bu::String &Bu::operator<<( Bu::String &dst, const Bu::String &sIn )
 {
-        dst = sIn;
-        return dst;
+    dst = sIn;
+    return dst;
 }
 
 Bu::ArchiveBase &Bu::operator<<( Bu::ArchiveBase &ar, const Bu::String &s )
 {
-        long n = s.getSize();
-        ar << n;
-        ar.write( s.getConstStr(), n );
-        return ar;
+    long n = s.getSize();
+    ar << n;
+    ar.write( s.getConstStr(), n );
+    return ar;
 }
 
 Bu::ArchiveBase &Bu::operator>>( Bu::ArchiveBase &ar, Bu::String &s )
 {
-        long n;
-        ar >> n;
-        s.setSize( n );
-        ar.read( s.getStr(), n );
-        return ar;
+    long n;
+    ar >> n;
+    s.setSize( n );
+    ar.read( s.getStr(), n );
+    return ar;
 }
 
diff --git a/src/stable/string.h b/src/stable/string.h
index 197821d..3be5bb9 100644
--- a/src/stable/string.h
+++ b/src/stable/string.h
@@ -22,1055 +22,1055 @@
 
 namespace Bu
 {
-        class String;
-        class MemBuf;
-
-        /** @cond DEVEL */
-        class StringCore
-        {
-        friend class String;
-        friend class SharedCore<String, StringCore>;
-        private:
-                struct Chunk
-                {
-                        long nLength;
-                        char *pData;
-                        Chunk *pNext;
-                };
-
-                StringCore();
-                StringCore( const StringCore &rSrc );
-                virtual ~StringCore();
-
-                mutable long nLength;
-                mutable Chunk *pFirst;
-                mutable Chunk *pLast;
-
-                void clear() const;
-                Chunk *newChunk() const;
-                Chunk *newChunk( long nLen ) const;
-                Chunk *copyChunk( Chunk *pSrc ) const;
-                void appendChunk( Chunk *pNewChunk );
-                void prependChunk( Chunk *pNewChunk );
-        };
-        /** @endcond */
-
-        /**
-         */
-        class String : public SharedCore<String, StringCore>
-        {
-        protected:
-                using SharedCore<String, StringCore >::core;
-                using SharedCore<String, StringCore >::_hardCopy;
-
-        private:
-                typedef StringCore::Chunk Chunk;
-
-        public: // Iterators
-                struct iterator;
-                typedef struct const_iterator
-                {
-                        friend class String;
-                        friend struct iterator;
-                private:
-                        const_iterator( Chunk *pChunk, int iPos ) :
-                                pChunk( pChunk ),
-                                iPos( iPos )
-                        {
-                        }
-
-                        Chunk *pChunk;
-                        int iPos;
-
-                public:
-                        const_iterator( const const_iterator &i ) :
-                                pChunk( i.pChunk ),
-                                iPos( i.iPos )
-                        {
-                        }
-                        
-                        const_iterator( const struct iterator &i ) :
-                                pChunk( i.pChunk ),
-                                iPos( i.iPos )
-                        {
-                        }
-
-                        const_iterator() :
-                                pChunk( NULL ),
-                                iPos( 0 )
-                        {
-                        }
-
-                        bool operator==( const const_iterator &i ) const
-                        {
-                                return pChunk == i.pChunk && iPos == i.iPos;
-                        }
-
-                        bool operator!=( const const_iterator &i ) const
-                        {
-                                return !(*this == i);
-                        }
-
-                        const_iterator &operator=( const const_iterator &i )
-                        {
-                                pChunk = i.pChunk;
-                                iPos = i.iPos;
-                                return *this;
-                        }
-                        
-                        const_iterator &operator=( const iterator &i )
-                        {
-                                pChunk = i.pChunk;
-                                iPos = i.iPos;
-                                return *this;
-                        }
-
-                        const_iterator &operator++()
-                        {
-                                if( !pChunk ) return *this;
-                                iPos++;
-                                if( iPos >= pChunk->nLength )
-                                {
-                                        iPos = 0;
-                                        pChunk = pChunk->pNext;
-                                }
-                                return *this;
-                        }
-
-                        const_iterator &operator++( int )
-                        {
-                                if( !pChunk ) return *this;
-                                iPos++;
-                                if( iPos >= pChunk->nLength )
-                                {
-                                        iPos = 0;
-                                        pChunk = pChunk->pNext;
-                                }
-                                return *this;
-                        }
-
-                        const_iterator &operator+=( int iAmnt )
-                        {
-                                if( !pChunk ) return *this;
-                                iPos += iAmnt;
-                                while( iPos >= pChunk->nLength )
-                                {
-                                        iPos -= pChunk->nLength;
-                                        pChunk = pChunk->pNext;
-                                        if( pChunk == NULL )
-                                                break;
-                                }
-                                return *this;
-                        }
-
-                        const_iterator operator+( int iAmnt ) const
-                        {
-                                if( !pChunk ) return *this;
-                                const_iterator ret( *this );
-                                ret += iAmnt;
-                                return ret;
-                        }
-
-                        const char &operator *() const
-                        {
-                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid const_iterator.");
-                                return pChunk->pData[iPos];
-                        }
-
-                        bool operator==( const char &c ) const
-                        {
-                                if( !pChunk ) return false;
-                                return pChunk->pData[iPos] == c;
-                        }
-
-                        bool operator!=( const char &c ) const
-                        {
-                                if( !pChunk ) return false;
-                                return pChunk->pData[iPos] != c;
-                        }
-                        
-                        operator bool() const
-                        {
-                                return pChunk != NULL;
-                        }
-
-                        bool isValid() const
-                        {
-                                return pChunk != NULL;
-                        }
-
-                        bool compare( const const_iterator &c ) const
-                        {
-                                const_iterator a = *this;
-                                const_iterator b = c;
-                                if( a == b )
-                                        return true;
-                                for(; a && b; a++, b++ )
-                                {
-                                        if( *a != *b )
-                                                return false;
-                                }
-                                if( (bool)a != (bool)b )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const const_iterator &c, int nLen ) const
-                        {
-                                const_iterator a = *this;
-                                const_iterator b = c;
-                                if( a == b )
-                                        return true;
-                                for(int j = 0; j < nLen; a++, b++, j++ )
-                                {
-                                        if( !a || !b || *a != *b )
-                                                return false;
-                                }
-                                return true;
-                        }
-
-                        bool compare( const char *c ) const
-                        {
-                                if( !pChunk ) return false;
-                                const_iterator a = *this;
-                                for(; a && *c; a++, c++ )
-                                {
-                                        if( *a != *c )
-                                                return false;
-                                }
-                                if( a.isValid() != (*c!=(char)0) )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const char *c, int nLen ) const
-                        {
-                                if( !pChunk ) return false;
-                                const_iterator a = *this;
-                                int j = 0;
-                                for(; a && j < nLen; a++, c++, j++ )
-                                {
-                                        if( *a != *c )
-                                                return false;
-                                }
-                                if( j < nLen )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const String &s ) const
-                        {
-                                if( !pChunk ) return false;
-                                return compare( s.begin() );
-                        }
-
-                        bool compare( const String &s, int nLen ) const
-                        {
-                                if( !pChunk ) return false;
-                                return compare( s.begin(), nLen );
-                        }
-
-                        const_iterator find( const char c ) const
-                        {
-                                for( const_iterator i = *this; i; i++ )
-                                {
-                                        if( *i == c )
-                                                return i;
-                                }
-                                return const_iterator( NULL, 0 );
-                        }
-
-                        const_iterator find( const char *pStr, int nLen ) const
-                        {
-                                for( const_iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( pStr, nLen ) )
-                                                return i;
-                                }
-                                return const_iterator( NULL, 0 );
-                        }
-
-                        const_iterator find( const String &s ) const
-                        {
-                                for( const_iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( s ) )
-                                                return i;
-                                }
-                                return const_iterator( NULL, 0 );
-                        }
-
-                        const_iterator find( const String &s, int nLen ) const
-                        {
-                                for( const_iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( s, nLen ) )
-                                                return i;
-                                }
-                                return const_iterator( NULL, 0 );
-                        }
-                } const_iterator;
-                
-                typedef struct iterator
-                {
-                        friend class String;
-                        friend struct const_iterator;
-                private:
-                        iterator( Chunk *pChunk, int iPos ) :
-                                pChunk( pChunk ),
-                                iPos( iPos )
-                        {
-                        }
-
-                        Chunk *pChunk;
-                        int iPos;
-
-                public:
-                        iterator( const iterator &i ) :
-                                pChunk( i.pChunk ),
-                                iPos( i.iPos )
-                        {
-                        }
-
-                        iterator() :
-                                pChunk( NULL ),
-                                iPos( 0 )
-                        {
-                        }
-
-                        operator const_iterator() const
-                        {
-                                return const_iterator( pChunk, iPos );
-                        }
-
-                        bool operator==( const iterator &i ) const
-                        {
-                                return pChunk == i.pChunk && iPos == i.iPos;
-                        }
-
-                        bool operator!=( const iterator &i ) const
-                        {
-                                return !(*this == i);
-                        }
-
-                        iterator &operator=( const iterator &i )
-                        {
-                                pChunk = i.pChunk;
-                                iPos = i.iPos;
-                                return *this;
-                        }
-
-                        iterator &operator++()
-                        {
-                                if( !pChunk ) return *this;
-                                iPos++;
-                                if( iPos >= pChunk->nLength )
-                                {
-                                        iPos = 0;
-                                        pChunk = pChunk->pNext;
-                                }
-                                return *this;
-                        }
-
-                        iterator &operator++( int )
-                        {
-                                if( !pChunk ) return *this;
-                                iPos++;
-                                if( iPos >= pChunk->nLength )
-                                {
-                                        iPos = 0;
-                                        pChunk = pChunk->pNext;
-                                }
-                                return *this;
-                        }
-
-                        iterator &operator+=( int iAmnt )
-                        {
-                                if( !pChunk ) return *this;
-                                iPos += iAmnt;
-                                while( iPos >= pChunk->nLength )
-                                {
-                                        iPos -= pChunk->nLength;
-                                        pChunk = pChunk->pNext;
-                                        if( pChunk == NULL )
-                                                break;
-                                }
-                                return *this;
-                        }
-
-                        iterator operator+( int iAmnt ) const
-                        {
-                                if( !pChunk ) return *this;
-                                iterator ret( *this );
-                                ret += iAmnt;
-                                return ret;
-                        }
-
-                        char &operator*()
-                        {
-                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
-                                return pChunk->pData[iPos];
-                        }
-
-                        const char &operator*() const
-                        {
-                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
-                                return pChunk->pData[iPos];
-                        }
-
-                        bool operator==( const char &c ) const
-                        {
-                                if( !pChunk ) return false;
-                                return pChunk->pData[iPos] == c;
-                        }
-
-                        bool operator!=( const char &c ) const
-                        {
-                                if( !pChunk ) return false;
-                                return pChunk->pData[iPos] != c;
-                        }
-
-                        iterator &operator=( const char &c )
-                        {
-                                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
-                                pChunk->pData[iPos] = c;
-                                return *this;
-                        }
-
-                        operator bool() const
-                        {
-                                return pChunk != NULL;
-                        }
-
-                        bool isValid() const
-                        {
-                                return pChunk != NULL;
-                        }
-
-                        bool compare( const const_iterator &c ) const
-                        {
-                                const_iterator a( *this );
-                                const_iterator b = c;
-                                if( a == b )
-                                        return true;
-                                for(; a && b; a++, b++ )
-                                {
-                                        if( *a != *b )
-                                                return false;
-                                }
-                                if( (bool)a != (bool)b )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const const_iterator &c, int nLen ) const
-                        {
-                                const_iterator a( *this );
-                                const_iterator b = c;
-                                if( a == b )
-                                        return true;
-                                for(int j = 0; j < nLen; a++, b++, j++ )
-                                {
-                                        if( !a || !b || *a != *b )
-                                                return false;
-                                }
-                                return true;
-                        }
-
-                        bool compare( const char *c ) const
-                        {
-                                if( !pChunk ) return false;
-                                iterator a = *this;
-                                for(; a && *c; a++, c++ )
-                                {
-                                        if( *a != *c )
-                                                return false;
-                                }
-                                if( a.isValid() != (*c!=(char)0) )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const char *c, int nLen ) const
-                        {
-                                if( !pChunk ) return false;
-                                iterator a = *this;
-                                int j = 0;
-                                for(; a && j < nLen; a++, c++, j++ )
-                                {
-                                        if( *a != *c )
-                                                return false;
-                                }
-                                if( j < nLen )
-                                        return false;
-                                return true;
-                        }
-
-                        bool compare( const String &s ) const
-                        {
-                                if( !pChunk ) return false;
-                                return compare( s.begin() );
-                        }
-
-                        bool compare( const String &s, int nLen ) const
-                        {
-                                if( !pChunk ) return false;
-                                return compare( s.begin(), nLen );
-                        }
-
-                        iterator find( const char c ) const
-                        {
-                                for( iterator i = *this; i; i++ )
-                                {
-                                        if( *i == c )
-                                                return i;
-                                }
-                                return iterator( NULL, 0 );
-                        }
-
-                        iterator find( const char *pStr, int nLen ) const
-                        {
-                                for( iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( pStr, nLen ) )
-                                                return i;
-                                }
-                                return iterator( NULL, 0 );
-                        }
-
-                        iterator find( const String &s ) const
-                        {
-                                for( iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( s ) )
-                                                return i;
-                                }
-                                return iterator( NULL, 0 );
-                        }
-
-                        iterator find( const String &s, int nLen ) const
-                        {
-                                for( iterator i = *this; i; i++ )
-                                {
-                                        if( i.compare( s, nLen ) )
-                                                return i;
-                                }
-                                return iterator( NULL, 0 );
-                        }
-                } iterator;
-
-        public:
-                String();
-                String( const char *pData );
-                String( const char *pData, long nLength );
-                String( const String &rSrc );
-                String( const String &rSrc, long nLength );
-                String( const String &rSrc, long nStart, long nLength );
-                String( long nSize );
-                String( const const_iterator &s );
-                String( const const_iterator &s, const const_iterator &e );
-                virtual ~String();
-
-                /**
-                 * Append data to your string.
-                 *@param pData (const char *) The data to append.
-                 */
-                void append( const char *pData );
-
-                /**
-                 * Append data to your string.
-                 *@param pData (const char *) The data to append.
-                 *@param nLen (long) The length of the data to append.
-                 */
-                void append( const char *pData, long nLen );
-                
-                /**
-                 * Append data to your string.
-                 *@param pData (const char *) The data to append.
-                 *@param nStart (long) The start position to copy from.
-                 *@param nLen (long) The length of the data to append.
-                 */
-                void append( const char *pData, long nStart, long nLen );
-
-                /**
-                 * Append a single char to your string.
-                 *@param cData (const char &) The character to append.
-                 */
-                void append( const char &cData );
-
-                /**
-                 * Append another String to this one.
-                 *@param sData (String &) The String to append.
-                 *@todo This function can be made much faster by not using getStr()
-                 */
-                void append( const String & sData );
-                
-                /**
-                 * Append another String to this one.
-                 *@param sData (String &) The String to append.
-                 *@param nLen How much data to append.
-                 *@todo This function can be made much faster by not using getStr()
-                 */
-                void append( const String & sData, long nLen );
-                
-                /**
-                 * Append another String to this one.
-                 *@param sData (String &) The String to append.
-                 *@param nStart Start position in sData to start copying from.
-                 *@param nLen How much data to append.
-                 *@todo This function can be made much faster by not using getStr()
-                 */
-                void append( const String & sData, long nStart, long nLen );
-                
-                /**
-                 * Append data to this String using the passed in iterator as a base.
-                 * The iterator is const, it is not changed.
-                 *@param s Iterator from any compatible String to copy data from.
-                 */
-                void append( const const_iterator &s );
-
-                /**
-                 * Append data to this String using the passed in iterator as a base.
-                 * The iterator is const, it is not changed.
-                 *@param s Iterator from any compatible String to copy data from.
-                 */
-                void append( const iterator &s );
-
-                /**
-                 * Append data to this String using the passed in iterator as a base,
-                 * and copy data until the ending iterator is reached.  The character
-                 * at the ending iterator is not copied.
-                 * The iterators are const, they are not changed.
-                 *@param s Iterator from any compatible String to copy data from.
-                 *@param e Iterator to stop copying at.
-                 */
-                void append( const const_iterator &s, const const_iterator &e );
-                
-                /**
-                 * Prepend another String to this one.
-                 *@param sData (String &) The String to prepend.
-                 *@todo This function can be made much faster by not using getStr()
-                 */
-                void prepend( const String & sData );
-
-                /**
-                 * Prepend data to your string.
-                 *@param pData (const char *) The data to prepend.
-                 */
-                void prepend( const char *pData );
-
-                /**
-                 * Prepend data to your string.
-                 *@param pData (const char *) The data to prepend.
-                 *@param nLen (long) The length of the data to prepend.
-                 */
-                void prepend( const char *pData, long nLen );
-
-                void prepend( const char c );
-
-                /**
-                 * Insert pData before byte nPos, that is, the first byte of pData will
-                 * start at nPos.  This could probably be made faster by avoiding
-                 * flattening.
-                 */
-                void insert( long nPos, const char *pData, long nLen );
-
-                void insert( long nPos, const String &str );
-
-                /**
-                 *@todo This function shouldn't use strlen, we should add our own to
-                 * this class, one that can be overridden in a specific implementation.
-                 */
-                void insert( long nPos, const char *pData );
-
-                void remove( long nPos, long nLen );
-
-                /**
-                 * Clear all data from the string.
-                 */
-                void clear();
-
-                String replace( const String &fnd, const String &rep ) const;
-
-                /**
-                 * Force the string to resize
-                 *@param nNewSize (long) The new size of the string.
-                 */
-                void resize( long nNewSize );
-
-                /**
-                 * Get the current size of the string.
-                 *@returns (long) The current size of the string.
-                 */
-                long getSize() const;
-                
-                /**
-                 * Get a pointer to the string array.
-                 *@returns (char *) The string data.
-                 */
-                char *getStr();
-                
-                /**
-                 * Get a const pointer to the string array.
-                 *@returns (const char *) The string data.
-                 */
-                const char *getStr() const;
-
-                /**
-                 * A convinience function, this one won't cause as much work as the
-                 * non-const getStr, so if you're not changing the data, consider it.
-                 */
-                const char *getConstStr() const;
-
-                String getSubStrIdx( long iStart, long iSize=-1 ) const;
-
-                String getSubStr( const_iterator iBegin,
-                                const_iterator iEnd=String::const_iterator() ) const;
-
-                Bu::List<String> split( const char c ) const;
-
-                /**
-                 * Plus equals operator for String.
-                 *@param pData (const char *) The data to append to your String.
-                 */
-                String &operator+=( const char *pData );
-                
-                /**
-                 * Plus equals operator for String.
-                 *@param rSrc (const String &) The String to append to your String.
-                 */
-                String &operator+=( const String &rSrc );
-
-                String &operator+=( const String::const_iterator &i );
-
-                /**
-                 * Plus equals operator for String.
-                 *@param cData (const char) The character to append to your String.
-                 */
-                String &operator+=( const char cData );
-
-                /**
-                 * Assignment operator.
-                 *@param pData (const char *) The character array to append to your
-                 *              String.
-                 */
-                String &operator=( const char *pData );
-
-                String operator+( const String &rRight ) const;
-
-                String operator+( const char *pRight ) const;
-
-                String operator+( char *pRight ) const;
-
-                /**
-                 * Reset your String to this character array.
-                 *@param pData (const char *) The character array to set your String to.
-                 */
-                void set( const char *pData );
-
-                /**
-                 * Reset your String to this character array.
-                 *@param pData (const char *) The character array to set your String to.
-                 *@param nSize (long) The length of the inputted character array.
-                 */
-                void set( const char *pData, long nSize );
-
-                void set( const char *pData, long nStart, long nSize );
-                
-                void set( const String &rData );
-
-                void set( const String &rData, long nSize );
-
-                void set( const String &rData, long nStart, long nSize );
-
-                void set( const_iterator s );
-
-                void set( const_iterator s, const_iterator e );
-
-                /**
-                 * Resize the string, possibly to make room for a copy.  At the moment
-                 * this operation *is* destructive.  What was in the string will in no
-                 * way be preserved.  This is, however, very fast.  If you want to
-                 * keep your data check out resize.
-                 *@param iSize the new size in bytes.  The string is guranteed to have
-                 * at least this much contiguous space available when done.
-                 */
-                void setSize( long iSize );
-
-                /**
-                 * Equals comparison operator.
-                 *@param pData (const char *) The character array to compare your String
-                 *              to.
-                 */
-                bool operator==( const char *pData ) const;
-                
-                /**
-                 * Equals comparison operator.
-                 *@param pData (const String &) The String to compare your String to.
-                 */
-                bool operator==( const String &pData ) const;
-
-                /**
-                 * Not equals comparison operator.
-                 *@param pData (const char *) The character array to compare your String
-                 *              to.
-                 */
-                bool operator!=(const char *pData ) const;
-                
-                /**
-                 * Not equals comparison operator.
-                 *@param pData (const String &) The String to compare your String to.
-                 */
-                bool operator!=(const String &pData ) const;
-
-                bool operator<(const String &pData ) const;
-                
-                bool operator<=(const String &pData ) const;
-
-                bool operator>(const String &pData ) const;
-
-                bool operator>=(const String &pData ) const;
-
-                /**
-                 * Indexing operator
-                 *@param nIndex (long) The index of the character you want.
-                 *@returns (char &) The character at position (nIndex).
-                 */
-                char &operator[]( long nIndex );
-                
-                /**
-                 * Const indexing operator
-                 *@param nIndex (long) The index of the character you want.
-                 *@returns (const char &) The character at position (nIndex).
-                 */
-                const char &operator[]( long nIndex ) const;
-
-                bool isSet() const;
-
-                bool compareSub( const char *pData, long nIndex, long nLen ) const;
-
-                bool compareSub( const String &rData, long nIndex, long nLen ) const;
-                
-                /**
-                 * Is the character at index (nIndex) white space?
-                 *@param nIndex (long) The index of the character you want to check.
-                 *@returns (bool) Is it white space?
-                 */
-                bool isWS( long nIndex ) const;
-
-                /**
-                 * Is the character at index (nIndex) a letter?
-                 *@param nIndex (long) The index of the character you want to check.
-                 *@returns (bool) Is it a letter?
-                 */
-                bool isAlpha( long nIndex ) const;
-
-                /**
-                 * Convert your alpha characters to lower case.
-                 */
-                String toLower() const;
-
-                /**
-                 * Convert your alpha characters to upper case.
-                 */
-                String toUpper() const;
-
-                const_iterator find( const char cChar,
-                                const_iterator iStart=const_iterator() ) const;
-
-                const_iterator find( const char *sText, int nLen,
-                                const_iterator iStart=const_iterator() ) const;
-
-                const_iterator find( const String &rStr,
-                                const_iterator iStart=const_iterator() ) const;
-
-                const_iterator find( const String &rStr, int nLen,
-                                const_iterator iStart=const_iterator() ) const;
-
-                iterator find( const char cChar,
-                                const_iterator iStart=const_iterator() );
-
-                iterator find( const char *sText, int nLen,
-                                const_iterator iStart=const_iterator() );
-
-                iterator find( const String &rStr,
-                                const_iterator iStart=const_iterator() );
-
-                iterator find( const String &rStr, int nLen,
-                                const_iterator iStart=const_iterator() );
-
-                /**
-                 * Find the index of the first occurrance of cChar
-                 *@param cChar The character to search for.
-                 *@param iStart The position in the string to start searching from.
-                 *@returns (long) The index of the first occurrance. -1 for not found.
-                 */
-                long findIdx( const char cChar, long iStart=0 ) const;
-                
-                /**
-                 * Find the index of the first occurrance of sText
-                 *@param sText The null-terminated string to search for.
-                 *@param iStart The position in the string to start searching from.
-                 *@returns The index of the first occurrance. -1 for not found.
-                 */
-                long findIdx( const char *sText, long iStart=0 ) const;
-
-                /**
-                 * Do a reverse search for (sText)
-                 *@param sText (const char *) The string to search for.
-                 *@returns (long) The index of the last occurrance. -1 for not found.
-                 */
-                long rfindIdx( const char *sText ) const;
-
-                /**
-                 * Remove nAmnt bytes from the front of the string.  This function
-                 * operates in O(n) time and should be used sparingly.
-                 */
-                void trimFront( long nAmnt );
-
-                void trimBack( long iAmnt );
-
-                Bu::String trimWhitespace() const;
-                
-                iterator begin();
-
-                const_iterator begin() const;
-
-                iterator end();
-
-                const_iterator end() const;
-
-                bool isEmpty() const;
-
-        private:
-                void flatten() const;
-                bool isFlat() const;
-
-        public:
-                class FormatProxyEndAction
-                {
-                public:
-                        virtual ~FormatProxyEndAction() { };
-                        virtual void operator()( const Bu::String &sFinal )=0;
-                };
-
-                class FormatProxy
-                {
-                friend class Bu::String;
-                private:
-                        FormatProxy( const String &rFmt, FormatProxyEndAction *pAct=NULL );
-
-                public:
-                        virtual ~FormatProxy();
-                        template<typename T>
-                        FormatProxy &arg( const T &x )
-                        {
-                                lArgs.append( Arg( x ) );
-
-                                return *this;
-                        }
-
-                        template<typename T>
-                        FormatProxy &arg( const T &x, const Bu::Fmt &f )
-                        {
-                                lArgs.append( Arg( x, f ) );
-
-                                return *this;
-                        }
-
-                        String end() const;
-                        operator String() const { return end(); }
-
-                private:
-                        const String &rFmt;
-                        class Arg
-                        {
-                        public:
-                                template<typename T>
-                                Arg( const T &v ) :
-                                        value( v )
-                                {
-                                }
-
-                                template<typename T>
-                                Arg( const T &v, const Bu::Fmt &f ) :
-                                        value( v ),
-                                        format( f )
-                                {
-                                }
-
-                                Bu::Variant value;
-                                Bu::Fmt format;
-                        };
-                        typedef Bu::List<Arg> ArgList;
-                        ArgList lArgs;
-                        FormatProxyEndAction *pAct;
-                        mutable bool bOpen;
-                };
-
-        public:
-                template<typename ArgType>
-                FormatProxy arg( const ArgType &x ) const
-                {
-                        return FormatProxy( *this ).arg( x );
-                }
-
-                template<typename ArgType>
-                FormatProxy arg( const ArgType &x, const Bu::Fmt &f ) const
-                {
-                        return FormatProxy( *this ).arg( x, f );
-                }
-                
-                FormatProxy format() const
-                {
-                        return FormatProxy( *this );
-                }
-
-                FormatProxy format( FormatProxyEndAction *pEndAction ) const
-                {
-                        return FormatProxy( *this, pEndAction );
-                }
-        };
-        
-        template<class T> String operator+( const T *pLeft, const String &rRight )
-        {
-                Bu::String ret( pLeft );
-                ret.append( rRight );
-                return ret;
-        }
-
-        ArchiveBase &operator<<( ArchiveBase &ar, const String &s );
-        ArchiveBase &operator>>( ArchiveBase &ar, String &s );
-
-        template<typename T>
-        uint32_t __calcHashCode( const T &k );
-
-        template<typename T>
-        bool __cmpHashKeys( const T &a, const T &b );
-
-        template<> uint32_t __calcHashCode<String>( const String &k );
-        template<> bool __cmpHashKeys<String>(
-                const String &a, const String &b );
-        
-        template<typename t> void __tracer_format( const t &v );
-        template<> void __tracer_format<String>( const String &v );
-
-        bool &operator<<( bool &dst, const String &sIn );
-        uint8_t &operator<<( uint8_t &dst, const String &sIn );
-        int8_t &operator<<( int8_t &dst, const String &sIn );
-        char &operator<<( char &dst, const String &sIn );
-        uint16_t &operator<<( uint16_t &dst, const String &sIn );
-        int16_t &operator<<( int16_t &dst, const String &sIn );
-        uint32_t &operator<<( uint32_t &dst, const String &sIn );
-        int32_t &operator<<( int32_t &dst, const String &sIn );
-        uint64_t &operator<<( uint64_t &dst, const String &sIn );
-        int64_t &operator<<( int64_t &dst, const String &sIn );
-        float &operator<<( float &dst, const String &sIn );
-        double &operator<<( double &dst, const String &sIn );
-        long double &operator<<( long double &dst, const String &sIn );
-        Bu::String &operator<<( Bu::String &dst, const String &sIn );
-
-        typedef Bu::List<String> StringList;
+    class String;
+    class MemBuf;
+
+    /** @cond DEVEL */
+    class StringCore
+    {
+    friend class String;
+    friend class SharedCore<String, StringCore>;
+    private:
+        struct Chunk
+        {
+            long nLength;
+            char *pData;
+            Chunk *pNext;
+        };
+
+        StringCore();
+        StringCore( const StringCore &rSrc );
+        virtual ~StringCore();
+
+        mutable long nLength;
+        mutable Chunk *pFirst;
+        mutable Chunk *pLast;
+
+        void clear() const;
+        Chunk *newChunk() const;
+        Chunk *newChunk( long nLen ) const;
+        Chunk *copyChunk( Chunk *pSrc ) const;
+        void appendChunk( Chunk *pNewChunk );
+        void prependChunk( Chunk *pNewChunk );
+    };
+    /** @endcond */
+
+    /**
+     */
+    class String : public SharedCore<String, StringCore>
+    {
+    protected:
+        using SharedCore<String, StringCore >::core;
+        using SharedCore<String, StringCore >::_hardCopy;
+
+    private:
+        typedef StringCore::Chunk Chunk;
+
+    public: // Iterators
+        struct iterator;
+        typedef struct const_iterator
+        {
+            friend class String;
+            friend struct iterator;
+        private:
+            const_iterator( Chunk *pChunk, int iPos ) :
+                pChunk( pChunk ),
+                iPos( iPos )
+            {
+            }
+
+            Chunk *pChunk;
+            int iPos;
+
+        public:
+            const_iterator( const const_iterator &i ) :
+                pChunk( i.pChunk ),
+                iPos( i.iPos )
+            {
+            }
+            
+            const_iterator( const struct iterator &i ) :
+                pChunk( i.pChunk ),
+                iPos( i.iPos )
+            {
+            }
+
+            const_iterator() :
+                pChunk( NULL ),
+                iPos( 0 )
+            {
+            }
+
+            bool operator==( const const_iterator &i ) const
+            {
+                return pChunk == i.pChunk && iPos == i.iPos;
+            }
+
+            bool operator!=( const const_iterator &i ) const
+            {
+                return !(*this == i);
+            }
+
+            const_iterator &operator=( const const_iterator &i )
+            {
+                pChunk = i.pChunk;
+                iPos = i.iPos;
+                return *this;
+            }
+            
+            const_iterator &operator=( const iterator &i )
+            {
+                pChunk = i.pChunk;
+                iPos = i.iPos;
+                return *this;
+            }
+
+            const_iterator &operator++()
+            {
+                if( !pChunk ) return *this;
+                iPos++;
+                if( iPos >= pChunk->nLength )
+                {
+                    iPos = 0;
+                    pChunk = pChunk->pNext;
+                }
+                return *this;
+            }
+
+            const_iterator &operator++( int )
+            {
+                if( !pChunk ) return *this;
+                iPos++;
+                if( iPos >= pChunk->nLength )
+                {
+                    iPos = 0;
+                    pChunk = pChunk->pNext;
+                }
+                return *this;
+            }
+
+            const_iterator &operator+=( int iAmnt )
+            {
+                if( !pChunk ) return *this;
+                iPos += iAmnt;
+                while( iPos >= pChunk->nLength )
+                {
+                    iPos -= pChunk->nLength;
+                    pChunk = pChunk->pNext;
+                    if( pChunk == NULL )
+                        break;
+                }
+                return *this;
+            }
+
+            const_iterator operator+( int iAmnt ) const
+            {
+                if( !pChunk ) return *this;
+                const_iterator ret( *this );
+                ret += iAmnt;
+                return ret;
+            }
+
+            const char &operator *() const
+            {
+                if( !pChunk ) throw Bu::ExceptionBase("Not a valid const_iterator.");
+                return pChunk->pData[iPos];
+            }
+
+            bool operator==( const char &c ) const
+            {
+                if( !pChunk ) return false;
+                return pChunk->pData[iPos] == c;
+            }
+
+            bool operator!=( const char &c ) const
+            {
+                if( !pChunk ) return false;
+                return pChunk->pData[iPos] != c;
+            }
+            
+            operator bool() const
+            {
+                return pChunk != NULL;
+            }
+
+            bool isValid() const
+            {
+                return pChunk != NULL;
+            }
+
+            bool compare( const const_iterator &c ) const
+            {
+                const_iterator a = *this;
+                const_iterator b = c;
+                if( a == b )
+                    return true;
+                for(; a && b; a++, b++ )
+                {
+                    if( *a != *b )
+                        return false;
+                }
+                if( (bool)a != (bool)b )
+                    return false;
+                return true;
+            }
+
+            bool compare( const const_iterator &c, int nLen ) const
+            {
+                const_iterator a = *this;
+                const_iterator b = c;
+                if( a == b )
+                    return true;
+                for(int j = 0; j < nLen; a++, b++, j++ )
+                {
+                    if( !a || !b || *a != *b )
+                        return false;
+                }
+                return true;
+            }
+
+            bool compare( const char *c ) const
+            {
+                if( !pChunk ) return false;
+                const_iterator a = *this;
+                for(; a && *c; a++, c++ )
+                {
+                    if( *a != *c )
+                        return false;
+                }
+                if( a.isValid() != (*c!=(char)0) )
+                    return false;
+                return true;
+            }
+
+            bool compare( const char *c, int nLen ) const
+            {
+                if( !pChunk ) return false;
+                const_iterator a = *this;
+                int j = 0;
+                for(; a && j < nLen; a++, c++, j++ )
+                {
+                    if( *a != *c )
+                        return false;
+                }
+                if( j < nLen )
+                    return false;
+                return true;
+            }
+
+            bool compare( const String &s ) const
+            {
+                if( !pChunk ) return false;
+                return compare( s.begin() );
+            }
+
+            bool compare( const String &s, int nLen ) const
+            {
+                if( !pChunk ) return false;
+                return compare( s.begin(), nLen );
+            }
+
+            const_iterator find( const char c ) const
+            {
+                for( const_iterator i = *this; i; i++ )
+                {
+                    if( *i == c )
+                        return i;
+                }
+                return const_iterator( NULL, 0 );
+            }
+
+            const_iterator find( const char *pStr, int nLen ) const
+            {
+                for( const_iterator i = *this; i; i++ )
+                {
+                    if( i.compare( pStr, nLen ) )
+                        return i;
+                }
+                return const_iterator( NULL, 0 );
+            }
+
+            const_iterator find( const String &s ) const
+            {
+                for( const_iterator i = *this; i; i++ )
+                {
+                    if( i.compare( s ) )
+                        return i;
+                }
+                return const_iterator( NULL, 0 );
+            }
+
+            const_iterator find( const String &s, int nLen ) const
+            {
+                for( const_iterator i = *this; i; i++ )
+                {
+                    if( i.compare( s, nLen ) )
+                        return i;
+                }
+                return const_iterator( NULL, 0 );
+            }
+        } const_iterator;
+        
+        typedef struct iterator
+        {
+            friend class String;
+            friend struct const_iterator;
+        private:
+            iterator( Chunk *pChunk, int iPos ) :
+                pChunk( pChunk ),
+                iPos( iPos )
+            {
+            }
+
+            Chunk *pChunk;
+            int iPos;
+
+        public:
+            iterator( const iterator &i ) :
+                pChunk( i.pChunk ),
+                iPos( i.iPos )
+            {
+            }
+
+            iterator() :
+                pChunk( NULL ),
+                iPos( 0 )
+            {
+            }
+
+            operator const_iterator() const
+            {
+                return const_iterator( pChunk, iPos );
+            }
+
+            bool operator==( const iterator &i ) const
+            {
+                return pChunk == i.pChunk && iPos == i.iPos;
+            }
+
+            bool operator!=( const iterator &i ) const
+            {
+                return !(*this == i);
+            }
+
+            iterator &operator=( const iterator &i )
+            {
+                pChunk = i.pChunk;
+                iPos = i.iPos;
+                return *this;
+            }
+
+            iterator &operator++()
+            {
+                if( !pChunk ) return *this;
+                iPos++;
+                if( iPos >= pChunk->nLength )
+                {
+                    iPos = 0;
+                    pChunk = pChunk->pNext;
+                }
+                return *this;
+            }
+
+            iterator &operator++( int )
+            {
+                if( !pChunk ) return *this;
+                iPos++;
+                if( iPos >= pChunk->nLength )
+                {
+                    iPos = 0;
+                    pChunk = pChunk->pNext;
+                }
+                return *this;
+            }
+
+            iterator &operator+=( int iAmnt )
+            {
+                if( !pChunk ) return *this;
+                iPos += iAmnt;
+                while( iPos >= pChunk->nLength )
+                {
+                    iPos -= pChunk->nLength;
+                    pChunk = pChunk->pNext;
+                    if( pChunk == NULL )
+                        break;
+                }
+                return *this;
+            }
+
+            iterator operator+( int iAmnt ) const
+            {
+                if( !pChunk ) return *this;
+                iterator ret( *this );
+                ret += iAmnt;
+                return ret;
+            }
+
+            char &operator*()
+            {
+                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
+                return pChunk->pData[iPos];
+            }
+
+            const char &operator*() const
+            {
+                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
+                return pChunk->pData[iPos];
+            }
+
+            bool operator==( const char &c ) const
+            {
+                if( !pChunk ) return false;
+                return pChunk->pData[iPos] == c;
+            }
+
+            bool operator!=( const char &c ) const
+            {
+                if( !pChunk ) return false;
+                return pChunk->pData[iPos] != c;
+            }
+
+            iterator &operator=( const char &c )
+            {
+                if( !pChunk ) throw Bu::ExceptionBase("Not a valid iterator.");
+                pChunk->pData[iPos] = c;
+                return *this;
+            }
+
+            operator bool() const
+            {
+                return pChunk != NULL;
+            }
+
+            bool isValid() const
+            {
+                return pChunk != NULL;
+            }
+
+            bool compare( const const_iterator &c ) const
+            {
+                const_iterator a( *this );
+                const_iterator b = c;
+                if( a == b )
+                    return true;
+                for(; a && b; a++, b++ )
+                {
+                    if( *a != *b )
+                        return false;
+                }
+                if( (bool)a != (bool)b )
+                    return false;
+                return true;
+            }
+
+            bool compare( const const_iterator &c, int nLen ) const
+            {
+                const_iterator a( *this );
+                const_iterator b = c;
+                if( a == b )
+                    return true;
+                for(int j = 0; j < nLen; a++, b++, j++ )
+                {
+                    if( !a || !b || *a != *b )
+                        return false;
+                }
+                return true;
+            }
+
+            bool compare( const char *c ) const
+            {
+                if( !pChunk ) return false;
+                iterator a = *this;
+                for(; a && *c; a++, c++ )
+                {
+                    if( *a != *c )
+                        return false;
+                }
+                if( a.isValid() != (*c!=(char)0) )
+                    return false;
+                return true;
+            }
+
+            bool compare( const char *c, int nLen ) const
+            {
+                if( !pChunk ) return false;
+                iterator a = *this;
+                int j = 0;
+                for(; a && j < nLen; a++, c++, j++ )
+                {
+                    if( *a != *c )
+                        return false;
+                }
+                if( j < nLen )
+                    return false;
+                return true;
+            }
+
+            bool compare( const String &s ) const
+            {
+                if( !pChunk ) return false;
+                return compare( s.begin() );
+            }
+
+            bool compare( const String &s, int nLen ) const
+            {
+                if( !pChunk ) return false;
+                return compare( s.begin(), nLen );
+            }
+
+            iterator find( const char c ) const
+            {
+                for( iterator i = *this; i; i++ )
+                {
+                    if( *i == c )
+                        return i;
+                }
+                return iterator( NULL, 0 );
+            }
+
+            iterator find( const char *pStr, int nLen ) const
+            {
+                for( iterator i = *this; i; i++ )
+                {
+                    if( i.compare( pStr, nLen ) )
+                        return i;
+                }
+                return iterator( NULL, 0 );
+            }
+
+            iterator find( const String &s ) const
+            {
+                for( iterator i = *this; i; i++ )
+                {
+                    if( i.compare( s ) )
+                        return i;
+                }
+                return iterator( NULL, 0 );
+            }
+
+            iterator find( const String &s, int nLen ) const
+            {
+                for( iterator i = *this; i; i++ )
+                {
+                    if( i.compare( s, nLen ) )
+                        return i;
+                }
+                return iterator( NULL, 0 );
+            }
+        } iterator;
+
+    public:
+        String();
+        String( const char *pData );
+        String( const char *pData, long nLength );
+        String( const String &rSrc );
+        String( const String &rSrc, long nLength );
+        String( const String &rSrc, long nStart, long nLength );
+        String( long nSize );
+        String( const const_iterator &s );
+        String( const const_iterator &s, const const_iterator &e );
+        virtual ~String();
+
+        /**
+         * Append data to your string.
+         *@param pData (const char *) The data to append.
+         */
+        void append( const char *pData );
+
+        /**
+         * Append data to your string.
+         *@param pData (const char *) The data to append.
+         *@param nLen (long) The length of the data to append.
+         */
+        void append( const char *pData, long nLen );
+        
+        /**
+         * Append data to your string.
+         *@param pData (const char *) The data to append.
+         *@param nStart (long) The start position to copy from.
+         *@param nLen (long) The length of the data to append.
+         */
+        void append( const char *pData, long nStart, long nLen );
+
+        /**
+         * Append a single char to your string.
+         *@param cData (const char &) The character to append.
+         */
+        void append( const char &cData );
+
+        /**
+         * Append another String to this one.
+         *@param sData (String &) The String to append.
+         *@todo This function can be made much faster by not using getStr()
+         */
+        void append( const String & sData );
+        
+        /**
+         * Append another String to this one.
+         *@param sData (String &) The String to append.
+         *@param nLen How much data to append.
+         *@todo This function can be made much faster by not using getStr()
+         */
+        void append( const String & sData, long nLen );
+        
+        /**
+         * Append another String to this one.
+         *@param sData (String &) The String to append.
+         *@param nStart Start position in sData to start copying from.
+         *@param nLen How much data to append.
+         *@todo This function can be made much faster by not using getStr()
+         */
+        void append( const String & sData, long nStart, long nLen );
+        
+        /**
+         * Append data to this String using the passed in iterator as a base.
+         * The iterator is const, it is not changed.
+         *@param s Iterator from any compatible String to copy data from.
+         */
+        void append( const const_iterator &s );
+
+        /**
+         * Append data to this String using the passed in iterator as a base.
+         * The iterator is const, it is not changed.
+         *@param s Iterator from any compatible String to copy data from.
+         */
+        void append( const iterator &s );
+
+        /**
+         * Append data to this String using the passed in iterator as a base,
+         * and copy data until the ending iterator is reached.  The character
+         * at the ending iterator is not copied.
+         * The iterators are const, they are not changed.
+         *@param s Iterator from any compatible String to copy data from.
+         *@param e Iterator to stop copying at.
+         */
+        void append( const const_iterator &s, const const_iterator &e );
+        
+        /**
+         * Prepend another String to this one.
+         *@param sData (String &) The String to prepend.
+         *@todo This function can be made much faster by not using getStr()
+         */
+        void prepend( const String & sData );
+
+        /**
+         * Prepend data to your string.
+         *@param pData (const char *) The data to prepend.
+         */
+        void prepend( const char *pData );
+
+        /**
+         * Prepend data to your string.
+         *@param pData (const char *) The data to prepend.
+         *@param nLen (long) The length of the data to prepend.
+         */
+        void prepend( const char *pData, long nLen );
+
+        void prepend( const char c );
+
+        /**
+         * Insert pData before byte nPos, that is, the first byte of pData will
+         * start at nPos.  This could probably be made faster by avoiding
+         * flattening.
+         */
+        void insert( long nPos, const char *pData, long nLen );
+
+        void insert( long nPos, const String &str );
+
+        /**
+         *@todo This function shouldn't use strlen, we should add our own to
+         * this class, one that can be overridden in a specific implementation.
+         */
+        void insert( long nPos, const char *pData );
+
+        void remove( long nPos, long nLen );
+
+        /**
+         * Clear all data from the string.
+         */
+        void clear();
+
+        String replace( const String &fnd, const String &rep ) const;
+
+        /**
+         * Force the string to resize
+         *@param nNewSize (long) The new size of the string.
+         */
+        void resize( long nNewSize );
+
+        /**
+         * Get the current size of the string.
+         *@returns (long) The current size of the string.
+         */
+        long getSize() const;
+        
+        /**
+         * Get a pointer to the string array.
+         *@returns (char *) The string data.
+         */
+        char *getStr();
+        
+        /**
+         * Get a const pointer to the string array.
+         *@returns (const char *) The string data.
+         */
+        const char *getStr() const;
+
+        /**
+         * A convinience function, this one won't cause as much work as the
+         * non-const getStr, so if you're not changing the data, consider it.
+         */
+        const char *getConstStr() const;
+
+        String getSubStrIdx( long iStart, long iSize=-1 ) const;
+
+        String getSubStr( const_iterator iBegin,
+                const_iterator iEnd=String::const_iterator() ) const;
+
+        Bu::List<String> split( const char c ) const;
+
+        /**
+         * Plus equals operator for String.
+         *@param pData (const char *) The data to append to your String.
+         */
+        String &operator+=( const char *pData );
+        
+        /**
+         * Plus equals operator for String.
+         *@param rSrc (const String &) The String to append to your String.
+         */
+        String &operator+=( const String &rSrc );
+
+        String &operator+=( const String::const_iterator &i );
+
+        /**
+         * Plus equals operator for String.
+         *@param cData (const char) The character to append to your String.
+         */
+        String &operator+=( const char cData );
+
+        /**
+         * Assignment operator.
+         *@param pData (const char *) The character array to append to your
+         *      String.
+         */
+        String &operator=( const char *pData );
+
+        String operator+( const String &rRight ) const;
+
+        String operator+( const char *pRight ) const;
+
+        String operator+( char *pRight ) const;
+
+        /**
+         * Reset your String to this character array.
+         *@param pData (const char *) The character array to set your String to.
+         */
+        void set( const char *pData );
+
+        /**
+         * Reset your String to this character array.
+         *@param pData (const char *) The character array to set your String to.
+         *@param nSize (long) The length of the inputted character array.
+         */
+        void set( const char *pData, long nSize );
+
+        void set( const char *pData, long nStart, long nSize );
+        
+        void set( const String &rData );
+
+        void set( const String &rData, long nSize );
+
+        void set( const String &rData, long nStart, long nSize );
+
+        void set( const_iterator s );
+
+        void set( const_iterator s, const_iterator e );
+
+        /**
+         * Resize the string, possibly to make room for a copy.  At the moment
+         * this operation *is* destructive.  What was in the string will in no
+         * way be preserved.  This is, however, very fast.  If you want to
+         * keep your data check out resize.
+         *@param iSize the new size in bytes.  The string is guranteed to have
+         * at least this much contiguous space available when done.
+         */
+        void setSize( long iSize );
+
+        /**
+         * Equals comparison operator.
+         *@param pData (const char *) The character array to compare your String
+         *      to.
+         */
+        bool operator==( const char *pData ) const;
+        
+        /**
+         * Equals comparison operator.
+         *@param pData (const String &) The String to compare your String to.
+         */
+        bool operator==( const String &pData ) const;
+
+        /**
+         * Not equals comparison operator.
+         *@param pData (const char *) The character array to compare your String
+         *      to.
+         */
+        bool operator!=(const char *pData ) const;
+        
+        /**
+         * Not equals comparison operator.
+         *@param pData (const String &) The String to compare your String to.
+         */
+        bool operator!=(const String &pData ) const;
+
+        bool operator<(const String &pData ) const;
+        
+        bool operator<=(const String &pData ) const;
+
+        bool operator>(const String &pData ) const;
+
+        bool operator>=(const String &pData ) const;
+
+        /**
+         * Indexing operator
+         *@param nIndex (long) The index of the character you want.
+         *@returns (char &) The character at position (nIndex).
+         */
+        char &operator[]( long nIndex );
+        
+        /**
+         * Const indexing operator
+         *@param nIndex (long) The index of the character you want.
+         *@returns (const char &) The character at position (nIndex).
+         */
+        const char &operator[]( long nIndex ) const;
+
+        bool isSet() const;
+
+        bool compareSub( const char *pData, long nIndex, long nLen ) const;
+
+        bool compareSub( const String &rData, long nIndex, long nLen ) const;
+        
+        /**
+         * Is the character at index (nIndex) white space?
+         *@param nIndex (long) The index of the character you want to check.
+         *@returns (bool) Is it white space?
+         */
+        bool isWS( long nIndex ) const;
+
+        /**
+         * Is the character at index (nIndex) a letter?
+         *@param nIndex (long) The index of the character you want to check.
+         *@returns (bool) Is it a letter?
+         */
+        bool isAlpha( long nIndex ) const;
+
+        /**
+         * Convert your alpha characters to lower case.
+         */
+        String toLower() const;
+
+        /**
+         * Convert your alpha characters to upper case.
+         */
+        String toUpper() const;
+
+        const_iterator find( const char cChar,
+                const_iterator iStart=const_iterator() ) const;
+
+        const_iterator find( const char *sText, int nLen,
+                const_iterator iStart=const_iterator() ) const;
+
+        const_iterator find( const String &rStr,
+                const_iterator iStart=const_iterator() ) const;
+
+        const_iterator find( const String &rStr, int nLen,
+                const_iterator iStart=const_iterator() ) const;
+
+        iterator find( const char cChar,
+                const_iterator iStart=const_iterator() );
+
+        iterator find( const char *sText, int nLen,
+                const_iterator iStart=const_iterator() );
+
+        iterator find( const String &rStr,
+                const_iterator iStart=const_iterator() );
+
+        iterator find( const String &rStr, int nLen,
+                const_iterator iStart=const_iterator() );
+
+        /**
+         * Find the index of the first occurrance of cChar
+         *@param cChar The character to search for.
+         *@param iStart The position in the string to start searching from.
+         *@returns (long) The index of the first occurrance. -1 for not found.
+         */
+        long findIdx( const char cChar, long iStart=0 ) const;
+        
+        /**
+         * Find the index of the first occurrance of sText
+         *@param sText The null-terminated string to search for.
+         *@param iStart The position in the string to start searching from.
+         *@returns The index of the first occurrance. -1 for not found.
+         */
+        long findIdx( const char *sText, long iStart=0 ) const;
+
+        /**
+         * Do a reverse search for (sText)
+         *@param sText (const char *) The string to search for.
+         *@returns (long) The index of the last occurrance. -1 for not found.
+         */
+        long rfindIdx( const char *sText ) const;
+
+        /**
+         * Remove nAmnt bytes from the front of the string.  This function
+         * operates in O(n) time and should be used sparingly.
+         */
+        void trimFront( long nAmnt );
+
+        void trimBack( long iAmnt );
+
+        Bu::String trimWhitespace() const;
+        
+        iterator begin();
+
+        const_iterator begin() const;
+
+        iterator end();
+
+        const_iterator end() const;
+
+        bool isEmpty() const;
+
+    private:
+        void flatten() const;
+        bool isFlat() const;
+
+    public:
+        class FormatProxyEndAction
+        {
+        public:
+            virtual ~FormatProxyEndAction() { };
+            virtual void operator()( const Bu::String &sFinal )=0;
+        };
+
+        class FormatProxy
+        {
+        friend class Bu::String;
+        private:
+            FormatProxy( const String &rFmt, FormatProxyEndAction *pAct=NULL );
+
+        public:
+            virtual ~FormatProxy();
+            template<typename T>
+            FormatProxy &arg( const T &x )
+            {
+                lArgs.append( Arg( x ) );
+
+                return *this;
+            }
+
+            template<typename T>
+            FormatProxy &arg( const T &x, const Bu::Fmt &f )
+            {
+                lArgs.append( Arg( x, f ) );
+
+                return *this;
+            }
+
+            String end() const;
+            operator String() const { return end(); }
+
+        private:
+            const String &rFmt;
+            class Arg
+            {
+            public:
+                template<typename T>
+                Arg( const T &v ) :
+                    value( v )
+                {
+                }
+
+                template<typename T>
+                Arg( const T &v, const Bu::Fmt &f ) :
+                    value( v ),
+                    format( f )
+                {
+                }
+
+                Bu::Variant value;
+                Bu::Fmt format;
+            };
+            typedef Bu::List<Arg> ArgList;
+            ArgList lArgs;
+            FormatProxyEndAction *pAct;
+            mutable bool bOpen;
+        };
+
+    public:
+        template<typename ArgType>
+        FormatProxy arg( const ArgType &x ) const
+        {
+            return FormatProxy( *this ).arg( x );
+        }
+
+        template<typename ArgType>
+        FormatProxy arg( const ArgType &x, const Bu::Fmt &f ) const
+        {
+            return FormatProxy( *this ).arg( x, f );
+        }
+        
+        FormatProxy format() const
+        {
+            return FormatProxy( *this );
+        }
+
+        FormatProxy format( FormatProxyEndAction *pEndAction ) const
+        {
+            return FormatProxy( *this, pEndAction );
+        }
+    };
+    
+    template<class T> String operator+( const T *pLeft, const String &rRight )
+    {
+        Bu::String ret( pLeft );
+        ret.append( rRight );
+        return ret;
+    }
+
+    ArchiveBase &operator<<( ArchiveBase &ar, const String &s );
+    ArchiveBase &operator>>( ArchiveBase &ar, String &s );
+
+    template<typename T>
+    uint32_t __calcHashCode( const T &k );
+
+    template<typename T>
+    bool __cmpHashKeys( const T &a, const T &b );
+
+    template<> uint32_t __calcHashCode<String>( const String &k );
+    template<> bool __cmpHashKeys<String>(
+        const String &a, const String &b );
+    
+    template<typename t> void __tracer_format( const t &v );
+    template<> void __tracer_format<String>( const String &v );
+
+    bool &operator<<( bool &dst, const String &sIn );
+    uint8_t &operator<<( uint8_t &dst, const String &sIn );
+    int8_t &operator<<( int8_t &dst, const String &sIn );
+    char &operator<<( char &dst, const String &sIn );
+    uint16_t &operator<<( uint16_t &dst, const String &sIn );
+    int16_t &operator<<( int16_t &dst, const String &sIn );
+    uint32_t &operator<<( uint32_t &dst, const String &sIn );
+    int32_t &operator<<( int32_t &dst, const String &sIn );
+    uint64_t &operator<<( uint64_t &dst, const String &sIn );
+    int64_t &operator<<( int64_t &dst, const String &sIn );
+    float &operator<<( float &dst, const String &sIn );
+    double &operator<<( double &dst, const String &sIn );
+    long double &operator<<( long double &dst, const String &sIn );
+    Bu::String &operator<<( Bu::String &dst, const String &sIn );
+
+    typedef Bu::List<String> StringList;
 };
 
 #endif
diff --git a/src/stable/substream.cpp b/src/stable/substream.cpp
index 7e3729b..c55dc04 100644
--- a/src/stable/substream.cpp
+++ b/src/stable/substream.cpp
@@ -8,12 +8,12 @@
 #include "bu/substream.h"
 
 Bu::SubStream::SubStream( Bu::Stream &rNext, Bu::size iSize ) :
-        Bu::Filter( rNext ),
-        iStart( 0 ),
-        iPos( 0 ),
-        iSize( iSize )
+    Bu::Filter( rNext ),
+    iStart( 0 ),
+    iPos( 0 ),
+    iSize( iSize )
 {
-        iStart = rNext.tell();
+    iStart = rNext.tell();
 }
 
 Bu::SubStream::~SubStream()
@@ -22,88 +22,88 @@ Bu::SubStream::~SubStream()
 
 Bu::size Bu::SubStream::read( void *pBuf, Bu::size nBytes )
 {
-        if( (Bu::size)nBytes > iSize-iPos )
-                nBytes = iSize-iPos;
-        nBytes = rNext.read( pBuf, nBytes );
-        iPos += nBytes;
-        return nBytes;
+    if( (Bu::size)nBytes > iSize-iPos )
+        nBytes = iSize-iPos;
+    nBytes = rNext.read( pBuf, nBytes );
+    iPos += nBytes;
+    return nBytes;
 }
 
 Bu::size Bu::SubStream::write( const void *pBuf, Bu::size nBytes )
 {
-        if( (Bu::size)nBytes > iSize-iPos )
-                nBytes = iSize-iPos;
-        nBytes = rNext.write( pBuf, nBytes );
-        iPos += nBytes;
-        return nBytes;
+    if( (Bu::size)nBytes > iSize-iPos )
+        nBytes = iSize-iPos;
+    nBytes = rNext.write( pBuf, nBytes );
+    iPos += nBytes;
+    return nBytes;
 }
 
 void Bu::SubStream::start()
 {
-        // doesn't mean anything...
+    // doesn't mean anything...
 }
 
 Bu::size Bu::SubStream::stop()
 {
-        // doesn't mean anything...
-        return 0;
+    // doesn't mean anything...
+    return 0;
 }
 
 void Bu::SubStream::close()
 {
-        // don't do anything?  maybe...
+    // don't do anything?  maybe...
 }
 
 Bu::size Bu::SubStream::tell()
 {
-        return iPos;
+    return iPos;
 }
 
 void Bu::SubStream::seek( Bu::size offset )
 {
-        if( iPos+offset < 0 )
-                offset = -iPos;
-        else if( iPos+offset > iSize )
-                offset = iSize-iPos;
-        rNext.seek( offset );
-        iPos += offset;
+    if( iPos+offset < 0 )
+        offset = -iPos;
+    else if( iPos+offset > iSize )
+        offset = iSize-iPos;
+    rNext.seek( offset );
+    iPos += offset;
 }
 
 void Bu::SubStream::setPos( Bu::size pos )
 {
-        if( pos < 0 )
-                pos = 0;
-        else if( pos > iSize )
-                pos = iSize;
-        iPos = pos;
-        pos += iStart;
-        rNext.setPos( pos );
+    if( pos < 0 )
+        pos = 0;
+    else if( pos > iSize )
+        pos = iSize;
+    iPos = pos;
+    pos += iStart;
+    rNext.setPos( pos );
 }
 
 void Bu::SubStream::setPosEnd( Bu::size pos )
 {
-        if( iSize-pos < 0 )
-                pos = 0;
-        else if( iSize-pos > iSize )
-                pos = iSize;
-        else
-                pos = iSize-pos;
-        iPos = pos;
-        rNext.setPos( iStart+pos );
+    if( iSize-pos < 0 )
+        pos = 0;
+    else if( iSize-pos > iSize )
+        pos = iSize;
+    else
+        pos = iSize-pos;
+    iPos = pos;
+    rNext.setPos( iStart+pos );
 }
 
 bool Bu::SubStream::isEos()
 {
-        return rNext.isEos() || iPos == iSize;
+    return rNext.isEos() || iPos == iSize;
 }
 
 bool Bu::SubStream::canRead()
 {
-        return rNext.canRead() && (iPos < iSize);
+    return rNext.canRead() && (iPos < iSize);
 }
 
 bool Bu::SubStream::canWrite()
 {
-        return rNext.canWrite() && (iPos < iSize);
+    return rNext.canWrite() && (iPos < iSize);
 }
 
diff --git a/src/stable/substream.h b/src/stable/substream.h
index 5905043..f79ed0b 100644
--- a/src/stable/substream.h
+++ b/src/stable/substream.h
@@ -12,52 +12,52 @@
 
 namespace Bu
 {
-        /**
-         * Creates a sub-stream of a given stream.  This allows you to read and
-         * write safely to a section of another stream, keeping all data within
-         * the given bounds.  The substream acts exactly like a top level stream
-         * when you reach the bounds of either the containing stream or the
-         * artificial bounds of the substream, except that unlike many stream types,
-         * when writing you cannot move beyond the bounds of the substream.  Reads,
-         * on the other hand, work exactly the same way, returning less data than
-         * requested when the end of the stream is reached.
-         *
-         * The substream always begins at the current position in the base stream,
-         * if you would like to skip some data first, simply seek.
-         *
-         * The substream class is safe to use with all blocking and non-blocking
-         * base streams, including sockets, however it can have unpredictable
-         * results when used on a buffering stream that may read more data than
-         * requested in order to complete a request such as the buffer or bzip2
-         * filters.
-         */
-        class SubStream : public Bu::Filter
-        {
-        public:
-                SubStream( Bu::Stream &rNext, Bu::size iSize );
-                virtual ~SubStream();
-
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Bu::Stream::write;
-
-                virtual void start();
-                virtual Bu::size stop();
-                virtual void close();
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-
-                virtual bool canRead();
-                virtual bool canWrite();
-
-        protected:
-                Bu::size iStart;
-                Bu::size iPos;
-                Bu::size iSize;
-        };
+    /**
+     * Creates a sub-stream of a given stream.  This allows you to read and
+     * write safely to a section of another stream, keeping all data within
+     * the given bounds.  The substream acts exactly like a top level stream
+     * when you reach the bounds of either the containing stream or the
+     * artificial bounds of the substream, except that unlike many stream types,
+     * when writing you cannot move beyond the bounds of the substream.  Reads,
+     * on the other hand, work exactly the same way, returning less data than
+     * requested when the end of the stream is reached.
+     *
+     * The substream always begins at the current position in the base stream,
+     * if you would like to skip some data first, simply seek.
+     *
+     * The substream class is safe to use with all blocking and non-blocking
+     * base streams, including sockets, however it can have unpredictable
+     * results when used on a buffering stream that may read more data than
+     * requested in order to complete a request such as the buffer or bzip2
+     * filters.
+     */
+    class SubStream : public Bu::Filter
+    {
+    public:
+        SubStream( Bu::Stream &rNext, Bu::size iSize );
+        virtual ~SubStream();
+
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Bu::Stream::write;
+
+        virtual void start();
+        virtual Bu::size stop();
+        virtual void close();
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+
+        virtual bool canRead();
+        virtual bool canWrite();
+
+    protected:
+        Bu::size iStart;
+        Bu::size iPos;
+        Bu::size iSize;
+    };
 };
 
 #endif
diff --git a/src/stable/synchroatom.h b/src/stable/synchroatom.h
index 2822b20..1d996b6 100644
--- a/src/stable/synchroatom.h
+++ b/src/stable/synchroatom.h
@@ -14,50 +14,50 @@
 
 namespace Bu
 {
-        /**
-         * A thread-safe wrapper class.
-         *@ingroup Threading
-         */
-        template <class T>
-        class SynchroAtom
-        {
-        public:
-                /**
-                 * Construct an empty queue.
-                 */
-                SynchroAtom()
-                {
-                }
-
-                SynchroAtom( const T &src ) :
-                        data( src )
-                {
-                }
-                
-                ~SynchroAtom()
-                {
-                }
-
-                T get()
-                {
-                        mOperate.lock();
-                        T ret = data;
-                        mOperate.unlock();
-                        return ret;
-                }
-
-                void set( const T &val )
-                {
-                        mOperate.lock();
-                        data = val;
-                        mOperate.unlock();
-                }
-
-        private:
-                T data;
-
-                Mutex mOperate; /**< The master mutex, used on all operations. */
-        };
+    /**
+     * A thread-safe wrapper class.
+     *@ingroup Threading
+     */
+    template <class T>
+    class SynchroAtom
+    {
+    public:
+        /**
+         * Construct an empty queue.
+         */
+        SynchroAtom()
+        {
+        }
+
+        SynchroAtom( const T &src ) :
+            data( src )
+        {
+        }
+        
+        ~SynchroAtom()
+        {
+        }
+
+        T get()
+        {
+            mOperate.lock();
+            T ret = data;
+            mOperate.unlock();
+            return ret;
+        }
+
+        void set( const T &val )
+        {
+            mOperate.lock();
+            data = val;
+            mOperate.unlock();
+        }
+
+    private:
+        T data;
+
+        Mutex mOperate; /**< The master mutex, used on all operations. */
+    };
 };
 
 #endif
diff --git a/src/stable/synchrocounter.h b/src/stable/synchrocounter.h
index ef86445..17de890 100644
--- a/src/stable/synchrocounter.h
+++ b/src/stable/synchrocounter.h
@@ -12,38 +12,38 @@
 
 namespace Bu
 {
-        /**
-         * A simple thread-safe counter class.  This is handy for assigning unique
-         * IDs to objects that are being created in different threads.
-         *@ingroup Threading Containers
-         */
-        template <class T>
-        class SynchroCounter
-        {
-        public:
-                SynchroCounter() :
-                        tCounter( 0 )
-                {
-                }
-                
-                virtual ~SynchroCounter()
-                {
-                }
+    /**
+     * A simple thread-safe counter class.  This is handy for assigning unique
+     * IDs to objects that are being created in different threads.
+     *@ingroup Threading Containers
+     */
+    template <class T>
+    class SynchroCounter
+    {
+    public:
+        SynchroCounter() :
+            tCounter( 0 )
+        {
+        }
+        
+        virtual ~SynchroCounter()
+        {
+        }
 
-                T next()
-                {
-                        mOperate.lock();
-                        T tRet = tCounter;
-                        tCounter++;
-                        mOperate.unlock();
+        T next()
+        {
+            mOperate.lock();
+            T tRet = tCounter;
+            tCounter++;
+            mOperate.unlock();
 
-                        return tRet;
-                }
+            return tRet;
+        }
 
-        private:
-                T tCounter;                             /**< The counter itself. */
-                Mutex mOperate; /**< The master mutex, used on all operations. */
-        };
+    private:
+        T tCounter;             /**< The counter itself. */
+        Mutex mOperate; /**< The master mutex, used on all operations. */
+    };
 }
 
 #endif
diff --git a/src/stable/synchroheap.h b/src/stable/synchroheap.h
index 9448625..f5216bf 100644
--- a/src/stable/synchroheap.h
+++ b/src/stable/synchroheap.h
@@ -14,137 +14,137 @@
 
 namespace Bu
 {
-        template<typename item, typename cmpfunc=__basicLTCmp<item>,
-                typename itemalloc=std::allocator<item> >
-        class SynchroHeap
-        {
-        public:
-                SynchroHeap()
-                {
-                }
-
-                virtual ~SynchroHeap()
-                {
-                }
-
-                void enqueue( item i )
-                {
-                        imData.lock();
-                        hData.enqueue( i );
-                        icBlock.signal();
-                        imData.unlock();
-                }
-
-                item dequeue( bool bBlock=false )
-                {
-                        imData.lock();
-                        if( hData.isEmpty() )
-                        {
-                                imData.unlock();
-
-                                if( bBlock )
-                                {
-                                        icBlock.lock();
-
-                                        while( hData.isEmpty() )
-                                                icBlock.wait();
-
-                                        imData.lock();
-                                        try
-                                        {
-                                                item iRet = hData.dequeue();
-                                                imData.unlock();
-                                                icBlock.unlock();
-                                                return iRet;
-                                        }
-                                        catch(...)
-                                        {
-                                                imData.unlock();
-                                                icBlock.unlock();
-                                                throw;
-                                        }
-                                }
-                                throw HeapException("Heap empty.");
-                        }
-                        else
-                        {
-                                try
-                                {
-                                        item iRet = hData.dequeue();
-                                        imData.unlock();
-                                        return iRet;
-                                }
-                                catch(...)
-                                {
-                                        imData.unlock();
-                                        throw;
-                                }
-                        }
-                }
-
-                item dequeue( int iSec, int iUSec )
-                {
-                        imData.lock();
-                        if( hData.isEmpty() )
-                        {
-                                imData.unlock();
-
-                                icBlock.lock();
-
-                                icBlock.wait( iSec, iUSec );
-
-                                imData.lock();
-                                try
-                                {
-                                        item iRet = hData.dequeue();
-                                        imData.unlock();
-                                        icBlock.unlock();
-                                        return iRet;
-                                }
-                                catch(...)
-                                {
-                                        imData.unlock();
-                                        icBlock.unlock();
-                                        throw;
-                                }
-                        }
-                        else
-                        {
-                                try
-                                {
-                                        item iRet = hData.dequeue();
-                                        imData.unlock();
-                                        return iRet;
-                                }
-                                catch(...)
-                                {
-                                        imData.unlock();
-                                        throw;
-                                }
-                        }
-                }
-                
-                bool isEmpty()
-                {
-                        imData.lock();
-                        bool bRet = hData.isEmpty();
-                        imData.unlock();
-                        return bRet;
-                }
-
-                int getSize()
-                {
-                        imData.lock();
-                        int iRet = hData.getSize();
-                        imData.unlock();
-                        return iRet;
-                }
-
-        private:
-                Heap< item, cmpfunc, itemalloc > hData;
-                Mutex imData;
-                Condition icBlock;
-        };
+    template<typename item, typename cmpfunc=__basicLTCmp<item>,
+        typename itemalloc=std::allocator<item> >
+    class SynchroHeap
+    {
+    public:
+        SynchroHeap()
+        {
+        }
+
+        virtual ~SynchroHeap()
+        {
+        }
+
+        void enqueue( item i )
+        {
+            imData.lock();
+            hData.enqueue( i );
+            icBlock.signal();
+            imData.unlock();
+        }
+
+        item dequeue( bool bBlock=false )
+        {
+            imData.lock();
+            if( hData.isEmpty() )
+            {
+                imData.unlock();
+
+                if( bBlock )
+                {
+                    icBlock.lock();
+
+                    while( hData.isEmpty() )
+                        icBlock.wait();
+
+                    imData.lock();
+                    try
+                    {
+                        item iRet = hData.dequeue();
+                        imData.unlock();
+                        icBlock.unlock();
+                        return iRet;
+                    }
+                    catch(...)
+                    {
+                        imData.unlock();
+                        icBlock.unlock();
+                        throw;
+                    }
+                }
+                throw HeapException("Heap empty.");
+            }
+            else
+            {
+                try
+                {
+                    item iRet = hData.dequeue();
+                    imData.unlock();
+                    return iRet;
+                }
+                catch(...)
+                {
+                    imData.unlock();
+                    throw;
+                }
+            }
+        }
+
+        item dequeue( int iSec, int iUSec )
+        {
+            imData.lock();
+            if( hData.isEmpty() )
+            {
+                imData.unlock();
+
+                icBlock.lock();
+
+                icBlock.wait( iSec, iUSec );
+
+                imData.lock();
+                try
+                {
+                    item iRet = hData.dequeue();
+                    imData.unlock();
+                    icBlock.unlock();
+                    return iRet;
+                }
+                catch(...)
+                {
+                    imData.unlock();
+                    icBlock.unlock();
+                    throw;
+                }
+            }
+            else
+            {
+                try
+                {
+                    item iRet = hData.dequeue();
+                    imData.unlock();
+                    return iRet;
+                }
+                catch(...)
+                {
+                    imData.unlock();
+                    throw;
+                }
+            }
+        }
+        
+        bool isEmpty()
+        {
+            imData.lock();
+            bool bRet = hData.isEmpty();
+            imData.unlock();
+            return bRet;
+        }
+
+        int getSize()
+        {
+            imData.lock();
+            int iRet = hData.getSize();
+            imData.unlock();
+            return iRet;
+        }
+
+    private:
+        Heap< item, cmpfunc, itemalloc > hData;
+        Mutex imData;
+        Condition icBlock;
+    };
 };
 
 #endif
diff --git a/src/stable/synchroqueue.h b/src/stable/synchroqueue.h
index 1c16e15..8dbedba 100644
--- a/src/stable/synchroqueue.h
+++ b/src/stable/synchroqueue.h
@@ -15,233 +15,233 @@
 
 namespace Bu
 {
-        /**
-         * A thread-safe queue class.  This class is a very simple queue with some
-         * cool extra functionality for use with the Synchro system.  The main extra
-         * that it provides is the option to either dequeue without blocking, with
-         * infinite blocking, or with timed blocking, which will return a value if
-         * something is enqueued within the specified time limit, or NULL if the
-         * time limit is exceded.
-         *@ingroup Threading Containers
-         */
-        template <class T>
-        class SynchroQueue
-        {
-        private:
-                /**
-                 * Helper struct.  Keeps track of linked-list items for the queue data.
-                 */
-                typedef struct Item
-                {
-                        T pData;
-                        Item *pNext;
-                } Item;
-
-        public:
-                /**
-                 * Construct an empty queue.
-                 */
-                SynchroQueue() :
-                        pStart( NULL ),
-                        pEnd( NULL ),
-                        nSize( 0 )
-                {
-                }
-                
-                /**
-                 * Destroy the queue.  This function will simply free all contained
-                 * structures.  If you stored pointers in the queue, this will lose the
-                 * pointers without cleaning up the memory they pointed to.  Make sure
-                 * you're queue is empty before allowing it to be destroyed!
-                 */
-                ~SynchroQueue()
-                {
-                        cBlock.lock();
-                        Item *pCur = pStart;
-                        while( pCur )
-                        {
-                                Item *pTmp = pCur->pNext;
-                                delete pCur;
-                                pCur = pTmp;
-                        }
-                        cBlock.unlock();
-                }
-
-                /**
-                 * Enqueue a pieces of data.  The new data will go at the end of the
-                 * queue, and unless another piece of data is enqueued, will be the
-                 * last piece of data to be dequeued.
-                 *@param pData The data to enqueue.  If this is not a primitive data
-                 * type it's probably best to use a pointer type.
-                 */
-                void enqueue( T pData )
-                {
-                        cBlock.lock();
-
-                        if( pStart == NULL )
-                        {
-                                pStart = pEnd = new Item;
-                                pStart->pData = pData;
-                                pStart->pNext = NULL;
-                                nSize++;
-                        }
-                        else
-                        {
-                                pEnd->pNext = new Item;
-                                pEnd = pEnd->pNext;
-                                pEnd->pData = pData;
-                                pEnd->pNext = NULL;
-                                nSize++;
-                        }
-
-                        cBlock.signal();
-
-                        cBlock.unlock();
-                }
-
-                /**
-                 * Dequeue the first item from the queue.  This function can operate in
-                 * two different modes, blocking and non-blocking.  In non-blocking
-                 * mode it will return immediately weather there was data in the queue
-                 * or not.  If there was data it will remove it from the queue and
-                 * return it to the caller.
-                 *
-                 * In blocking mode it will block forever wating for data to be
-                 * enqueued.  When data finally is enqueued this function will return
-                 * immediately with the new data.  The only way this function should
-                 * ever return a null in blocking mode is if the calling thread was
-                 * cancelled.  It's probably a good idea to check for NULL return
-                 * values even if you use blocking, just to be on the safe side.
-                 *@param bBlock Set to true to enable blocking, leave as false to work
-                 * in non-blocking mode.
-                 *@returns The next piece of data in the queue, or NULL if no data was
-                 * in the queue.
-                 */
-                T dequeue( bool bBlock=false )
-                {
-                        cBlock.lock();
-                        if( pStart == NULL )
-                        {
-                                if( bBlock )
-                                {
-                                        cBlock.wait();
-
-                                        if( pStart == NULL )
-                                        {
-                                                cBlock.unlock();
-                                                return NULL;
-                                        }
-                                        T pTmp = pStart->pData;
-                                        Item *pDel = pStart;
-                                        pStart = pStart->pNext;
-                                        delete pDel;
-                                        nSize--;
-                                        
-                                        cBlock.unlock();
-                                        return pTmp;
-
-                                }
-
-                                cBlock.unlock();
-                                return NULL;
-                        }
-                        else
-                        {
-                                T pTmp = pStart->pData;
-                                Item *pDel = pStart;
-                                pStart = pStart->pNext;
-                                delete pDel;
-                                nSize--;
-                        
-                                cBlock.unlock();
-                                return pTmp;
-                        }
-                }
-
-                /**
-                 * Operates just like the other dequeue function in blocking mode with
-                 * one twist.  This function will block for at most nSec seconds and
-                 * nUSec micro-seconds.  If the timer is up and no data is available,
-                 * this will just return NULL.  If data is enqueued before the timeout
-                 * expires, it will dequeue and exit immediately.
-                 *@param nSec The number of seconds to wait, max.
-                 *@param nUSec The number of micro-seconds to wait, max.
-                 *@returns The next piece of data in the queue, or NULL if the timeout
-                 * was exceeded.
-                 */
-                T dequeue( int nSec, int nUSec )
-                {
-                        cBlock.lock();
-                        if( pStart == NULL )
-                        {
-                                cBlock.wait( nSec, nUSec );
-
-                                if( pStart == NULL )
-                                {
-                                        cBlock.unlock();
-                                        return NULL;
-                                }
-                        
-                                T pTmp = pStart->pData;
-                                Item *pDel = pStart;
-                                pStart = pStart->pNext;
-                                delete pDel;
-                                nSize--;
-                                        
-                                cBlock.unlock();
-                                return pTmp;
-                        }
-                        else
-                        {
-                                T pTmp = pStart->pData;
-                                Item *pDel = pStart;
-                                pStart = pStart->pNext;
-                                delete pDel;
-                                nSize--;
-                        
-                                cBlock.unlock();
-                                return pTmp;
-                        }
-                }
-
-                /**
-                 * Checks to see if the queue has data in it or not.  Note that there
-                 * is no function to determine the length of the queue.  This data
-                 * isn't kept track of.  If you really need to know, fix this.
-                 *@returns True if the queue is empty, false if it has data in it.
-                 */
-                bool isEmpty()
-                {
-                        cBlock.lock();
-                        bool bEmpty = (pStart == NULL );
-                        cBlock.unlock();
-
-                        return bEmpty;
-                }
-
-                long getSize()
-                {
-                        cBlock.lock();
-                        long nRet = nSize;
-                        cBlock.unlock();
-
-                        return nRet;
-                }
-
-                void unblockAll()
-                {
-                        cBlock.lock();
-                        cBlock.broadcast();
-                        cBlock.unlock();
-                }
-
-        private:
-                Item *pStart;   /**< The start of the queue, the next element to dequeue. */
-                Item *pEnd;             /**< The end of the queue, the last element to dequeue. */
-                long nSize;             /**< The number of items in the queue. */
-
-                Condition cBlock;       /**< The condition for blocking dequeues. */
-        };
+    /**
+     * A thread-safe queue class.  This class is a very simple queue with some
+     * cool extra functionality for use with the Synchro system.  The main extra
+     * that it provides is the option to either dequeue without blocking, with
+     * infinite blocking, or with timed blocking, which will return a value if
+     * something is enqueued within the specified time limit, or NULL if the
+     * time limit is exceded.
+     *@ingroup Threading Containers
+     */
+    template <class T>
+    class SynchroQueue
+    {
+    private:
+        /**
+         * Helper struct.  Keeps track of linked-list items for the queue data.
+         */
+        typedef struct Item
+        {
+            T pData;
+            Item *pNext;
+        } Item;
+
+    public:
+        /**
+         * Construct an empty queue.
+         */
+        SynchroQueue() :
+            pStart( NULL ),
+            pEnd( NULL ),
+            nSize( 0 )
+        {
+        }
+        
+        /**
+         * Destroy the queue.  This function will simply free all contained
+         * structures.  If you stored pointers in the queue, this will lose the
+         * pointers without cleaning up the memory they pointed to.  Make sure
+         * you're queue is empty before allowing it to be destroyed!
+         */
+        ~SynchroQueue()
+        {
+            cBlock.lock();
+            Item *pCur = pStart;
+            while( pCur )
+            {
+                Item *pTmp = pCur->pNext;
+                delete pCur;
+                pCur = pTmp;
+            }
+            cBlock.unlock();
+        }
+
+        /**
+         * Enqueue a pieces of data.  The new data will go at the end of the
+         * queue, and unless another piece of data is enqueued, will be the
+         * last piece of data to be dequeued.
+         *@param pData The data to enqueue.  If this is not a primitive data
+         * type it's probably best to use a pointer type.
+         */
+        void enqueue( T pData )
+        {
+            cBlock.lock();
+
+            if( pStart == NULL )
+            {
+                pStart = pEnd = new Item;
+                pStart->pData = pData;
+                pStart->pNext = NULL;
+                nSize++;
+            }
+            else
+            {
+                pEnd->pNext = new Item;
+                pEnd = pEnd->pNext;
+                pEnd->pData = pData;
+                pEnd->pNext = NULL;
+                nSize++;
+            }
+
+            cBlock.signal();
+
+            cBlock.unlock();
+        }
+
+        /**
+         * Dequeue the first item from the queue.  This function can operate in
+         * two different modes, blocking and non-blocking.  In non-blocking
+         * mode it will return immediately weather there was data in the queue
+         * or not.  If there was data it will remove it from the queue and
+         * return it to the caller.
+         *
+         * In blocking mode it will block forever wating for data to be
+         * enqueued.  When data finally is enqueued this function will return
+         * immediately with the new data.  The only way this function should
+         * ever return a null in blocking mode is if the calling thread was
+         * cancelled.  It's probably a good idea to check for NULL return
+         * values even if you use blocking, just to be on the safe side.
+         *@param bBlock Set to true to enable blocking, leave as false to work
+         * in non-blocking mode.
+         *@returns The next piece of data in the queue, or NULL if no data was
+         * in the queue.
+         */
+        T dequeue( bool bBlock=false )
+        {
+            cBlock.lock();
+            if( pStart == NULL )
+            {
+                if( bBlock )
+                {
+                    cBlock.wait();
+
+                    if( pStart == NULL )
+                    {
+                        cBlock.unlock();
+                        return NULL;
+                    }
+                    T pTmp = pStart->pData;
+                    Item *pDel = pStart;
+                    pStart = pStart->pNext;
+                    delete pDel;
+                    nSize--;
+                    
+                    cBlock.unlock();
+                    return pTmp;
+
+                }
+
+                cBlock.unlock();
+                return NULL;
+            }
+            else
+            {
+                T pTmp = pStart->pData;
+                Item *pDel = pStart;
+                pStart = pStart->pNext;
+                delete pDel;
+                nSize--;
+            
+                cBlock.unlock();
+                return pTmp;
+            }
+        }
+
+        /**
+         * Operates just like the other dequeue function in blocking mode with
+         * one twist.  This function will block for at most nSec seconds and
+         * nUSec micro-seconds.  If the timer is up and no data is available,
+         * this will just return NULL.  If data is enqueued before the timeout
+         * expires, it will dequeue and exit immediately.
+         *@param nSec The number of seconds to wait, max.
+         *@param nUSec The number of micro-seconds to wait, max.
+         *@returns The next piece of data in the queue, or NULL if the timeout
+         * was exceeded.
+         */
+        T dequeue( int nSec, int nUSec )
+        {
+            cBlock.lock();
+            if( pStart == NULL )
+            {
+                cBlock.wait( nSec, nUSec );
+
+                if( pStart == NULL )
+                {
+                    cBlock.unlock();
+                    return NULL;
+                }
+            
+                T pTmp = pStart->pData;
+                Item *pDel = pStart;
+                pStart = pStart->pNext;
+                delete pDel;
+                nSize--;
+                    
+                cBlock.unlock();
+                return pTmp;
+            }
+            else
+            {
+                T pTmp = pStart->pData;
+                Item *pDel = pStart;
+                pStart = pStart->pNext;
+                delete pDel;
+                nSize--;
+            
+                cBlock.unlock();
+                return pTmp;
+            }
+        }
+
+        /**
+         * Checks to see if the queue has data in it or not.  Note that there
+         * is no function to determine the length of the queue.  This data
+         * isn't kept track of.  If you really need to know, fix this.
+         *@returns True if the queue is empty, false if it has data in it.
+         */
+        bool isEmpty()
+        {
+            cBlock.lock();
+            bool bEmpty = (pStart == NULL );
+            cBlock.unlock();
+
+            return bEmpty;
+        }
+
+        long getSize()
+        {
+            cBlock.lock();
+            long nRet = nSize;
+            cBlock.unlock();
+
+            return nRet;
+        }
+
+        void unblockAll()
+        {
+            cBlock.lock();
+            cBlock.broadcast();
+            cBlock.unlock();
+        }
+
+    private:
+        Item *pStart;   /**< The start of the queue, the next element to dequeue. */
+        Item *pEnd;     /**< The end of the queue, the last element to dequeue. */
+        long nSize;     /**< The number of items in the queue. */
+
+        Condition cBlock;   /**< The condition for blocking dequeues. */
+    };
 }
 
 #endif
diff --git a/src/stable/tafcomment.cpp b/src/stable/tafcomment.cpp
index ceda8e3..5168685 100644
--- a/src/stable/tafcomment.cpp
+++ b/src/stable/tafcomment.cpp
@@ -8,16 +8,16 @@
 #include "bu/tafcomment.h"
 
 Bu::TafComment::TafComment( const Bu::TafComment &rSrc ) :
-        TafNode( typeComment ),
-        sText( rSrc.sText ),
-        bEOL( rSrc.bEOL )
+    TafNode( typeComment ),
+    sText( rSrc.sText ),
+    bEOL( rSrc.bEOL )
 {
 }
 
 Bu::TafComment::TafComment( const Bu::String &sText, bool bEOL ) :
-        TafNode( typeComment ),
-        sText( sText ),
-        bEOL( bEOL )
+    TafNode( typeComment ),
+    sText( sText ),
+    bEOL( bEOL )
 {
 }
 
@@ -27,11 +27,11 @@ Bu::TafComment::~TafComment()
 
 const Bu::String &Bu::TafComment::getText() const
 {
-        return sText;
+    return sText;
 }
 
 bool Bu::TafComment::isEOLStyle() const
 {
-        return bEOL;
+    return bEOL;
 }
 
diff --git a/src/stable/tafcomment.h b/src/stable/tafcomment.h
index 80c6399..2f403e7 100644
--- a/src/stable/tafcomment.h
+++ b/src/stable/tafcomment.h
@@ -13,24 +13,24 @@
 
 namespace Bu
 {
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafComment : public TafNode
-        {
-        public:
-                TafComment( const Bu::TafComment &rSrc );
-                TafComment( const Bu::String &sText, bool bEOL=false );
-                virtual ~TafComment();
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafComment : public TafNode
+    {
+    public:
+        TafComment( const Bu::TafComment &rSrc );
+        TafComment( const Bu::String &sText, bool bEOL=false );
+        virtual ~TafComment();
 
-                const Bu::String &getText() const;
-                bool isEOLStyle() const;
+        const Bu::String &getText() const;
+        bool isEOLStyle() const;
 
-        private:
-                Bu::String sText;
-                bool bEOL;
-        };
+    private:
+        Bu::String sText;
+        bool bEOL;
+    };
 }
 
 #endif
diff --git a/src/stable/tafgroup.cpp b/src/stable/tafgroup.cpp
index 27af09e..7e15b26 100644
--- a/src/stable/tafgroup.cpp
+++ b/src/stable/tafgroup.cpp
@@ -10,215 +10,215 @@
 #include "bu/tafcomment.h"
 
 Bu::TafGroup::TafGroup( const TafGroup &rSrc ) :
-        TafNode( typeGroup ),
-        sName( rSrc.sName )
+    TafNode( typeGroup ),
+    sName( rSrc.sName )
 {
-        for( NodeList::const_iterator i = rSrc.lChildren.begin(); i; i++ )
-        {
-                switch( (*i)->getType() )
-                {
-                        case typeGroup:
-                                addChild( new TafGroup( *dynamic_cast<const TafGroup *>(*i) ) );
-                                break;
+    for( NodeList::const_iterator i = rSrc.lChildren.begin(); i; i++ )
+    {
+        switch( (*i)->getType() )
+        {
+            case typeGroup:
+                addChild( new TafGroup( *dynamic_cast<const TafGroup *>(*i) ) );
+                break;
 
-                        case typeProperty:
-                                addChild( new TafProperty( *dynamic_cast<const TafProperty *>(*i) ) );
-                                break;
+            case typeProperty:
+                addChild( new TafProperty( *dynamic_cast<const TafProperty *>(*i) ) );
+                break;
 
-                        case typeComment:
-                                addChild( new TafComment( *dynamic_cast<const TafComment *>(*i) ) );
-                                break;
-                }
-        }
+            case typeComment:
+                addChild( new TafComment( *dynamic_cast<const TafComment *>(*i) ) );
+                break;
+        }
+    }
 }
 
 Bu::TafGroup::TafGroup( const Bu::String &sName ) :
-        TafNode( typeGroup ),
-        sName( sName )
+    TafNode( typeGroup ),
+    sName( sName )
 {
 }
 
 Bu::TafGroup::~TafGroup()
 {
-        for( NodeList::iterator i = lChildren.begin(); i != lChildren.end(); i++ )
-        {
-                delete (*i);
-        }
+    for( NodeList::iterator i = lChildren.begin(); i != lChildren.end(); i++ )
+    {
+        delete (*i);
+    }
 }
 
 const Bu::String &Bu::TafGroup::getName() const
 {
-        return sName;
+    return sName;
 }
 
 void Bu::TafGroup::setName( const Bu::String &sName )
 {
-        this->sName = sName;
+    this->sName = sName;
 }
 
 Bu::TafNode *Bu::TafGroup::addChild( Bu::TafNode *pNode )
 {
-        switch( pNode->getType() )
-        {
-                case typeGroup:
-                        addChild( (Bu::TafGroup *)pNode );
-                        break;
+    switch( pNode->getType() )
+    {
+        case typeGroup:
+            addChild( (Bu::TafGroup *)pNode );
+            break;
 
-                case typeProperty:
-                        addChild( (Bu::TafProperty *)pNode );
-                        break;
+        case typeProperty:
+            addChild( (Bu::TafProperty *)pNode );
+            break;
 
-                case typeComment:
-                        addChild( (Bu::TafComment *)pNode );
-                        break;
-        }
+        case typeComment:
+            addChild( (Bu::TafComment *)pNode );
+            break;
+    }
 
-        return pNode;
+    return pNode;
 }
 
 Bu::TafGroup *Bu::TafGroup::addChild( TafGroup *pNode )
 {
-        TafGroup *pGroup = (TafGroup *)pNode;
-        if( !hChildren.has( pGroup->getName() ) )
-                hChildren.insert( pGroup->getName(), GroupList() );
-        hChildren.get( pGroup->getName() ).append( pGroup );
-        lChildren.append( pNode );
-        return pNode;
+    TafGroup *pGroup = (TafGroup *)pNode;
+    if( !hChildren.has( pGroup->getName() ) )
+        hChildren.insert( pGroup->getName(), GroupList() );
+    hChildren.get( pGroup->getName() ).append( pGroup );
+    lChildren.append( pNode );
+    return pNode;
 }
 
 Bu::TafProperty *Bu::TafGroup::addChild( TafProperty *pNode )
 {
-        TafProperty *pProperty = (TafProperty *)pNode;
-        if( !hProp.has( pProperty->getName() ) )
-                hProp.insert( pProperty->getName(), PropList() );
-        hProp.get( pProperty->getName() ).append( pProperty->getValue() );
-        lChildren.append( pNode );
-        return pNode;
+    TafProperty *pProperty = (TafProperty *)pNode;
+    if( !hProp.has( pProperty->getName() ) )
+        hProp.insert( pProperty->getName(), PropList() );
+    hProp.get( pProperty->getName() ).append( pProperty->getValue() );
+    lChildren.append( pNode );
+    return pNode;
 }
 
 Bu::TafComment *Bu::TafGroup::addChild( TafComment *pNode )
 {
-        lChildren.append( pNode );
-        return pNode;
+    lChildren.append( pNode );
+    return pNode;
 }
 
 Bu::TafGroup *Bu::TafGroup::addGroup( const Bu::String &sName )
 {
-        return addChild( new TafGroup( sName ) );
+    return addChild( new TafGroup( sName ) );
 }
 
 Bu::TafProperty *Bu::TafGroup::addProperty(
-        const Bu::String &sName, const Bu::String &sValue )
+    const Bu::String &sName, const Bu::String &sValue )
 {
-        return addChild( new TafProperty( sName, sValue ) );
+    return addChild( new TafProperty( sName, sValue ) );
 }
 
 bool Bu::TafGroup::hasChild( const Bu::String &sName ) const
 {
-        return hChildren.has( sName );
+    return hChildren.has( sName );
 }
 
 const Bu::TafGroup::GroupList &Bu::TafGroup::getChildren( const Bu::String &sName ) const
 {
-        try {
-                return hChildren.get( sName );
-        } catch( Bu::HashException &e )
-        {
-                throw Bu::TafException("No children of group \"%s\" match \"%s\".",
-                        this->sName.getStr(), sName.getStr() );
-        }
+    try {
+        return hChildren.get( sName );
+    } catch( Bu::HashException &e )
+    {
+        throw Bu::TafException("No children of group \"%s\" match \"%s\".",
+            this->sName.getStr(), sName.getStr() );
+    }
 }
 
 const Bu::TafGroup::NodeList &Bu::TafGroup::getChildren() const
 {
-        return lChildren;
+    return lChildren;
 }
 
 const Bu::TafGroup *Bu::TafGroup::getChild( const Bu::String &sName ) const
 {
-        try {
-                return hChildren.get( sName ).first();
-        } catch( Bu::HashException &e )
-        {
-                throw Bu::TafException("No children of group \"%s\" match \"%s\".",
-                        this->sName.getStr(), sName.getStr() );
-        }
+    try {
+        return hChildren.get( sName ).first();
+    } catch( Bu::HashException &e )
+    {
+        throw Bu::TafException("No children of group \"%s\" match \"%s\".",
+            this->sName.getStr(), sName.getStr() );
+    }
 }
 
 bool Bu::TafGroup::hasProperty( const Bu::String &sName ) const
 {
-        return hProp.has( sName );
+    return hProp.has( sName );
 }
 
 const Bu::TafGroup::PropList &Bu::TafGroup::getProperties( const Bu::String &sName ) const
 {
-        try {
-                return hProp.get( sName );
-        } catch( Bu::HashException &e )
-        {
-                throw Bu::TafException("No properties of group \"%s\" match \"%s\".",
-                        this->sName.getStr(), sName.getStr() );
-        }
+    try {
+        return hProp.get( sName );
+    } catch( Bu::HashException &e )
+    {
+        throw Bu::TafException("No properties of group \"%s\" match \"%s\".",
+            this->sName.getStr(), sName.getStr() );
+    }
 }
 
 const Bu::String &Bu::TafGroup::getProperty( const Bu::String &sName ) const
 {
-        try {
-                return hProp.get( sName ).first();
-        } catch( Bu::HashException &e )
-        {
-                throw Bu::TafException("No properties of group \"%s\" match \"%s\".",
-                        this->sName.getStr(), sName.getStr() );
-        }       
+    try {
+        return hProp.get( sName ).first();
+    } catch( Bu::HashException &e )
+    {
+        throw Bu::TafException("No properties of group \"%s\" match \"%s\".",
+            this->sName.getStr(), sName.getStr() );
+    }   
 }
 
 const Bu::String &Bu::TafGroup::getProperty( const Bu::String &sName,
-        const Bu::String &sDef ) const
+    const Bu::String &sDef ) const
 {
-        try
-        {
-                return hProp.get( sName ).first();
-        }
-        catch( Bu::HashException &e )
-        {
-                return sDef;
-        }
+    try
+    {
+        return hProp.get( sName ).first();
+    }
+    catch( Bu::HashException &e )
+    {
+        return sDef;
+    }
 }
 
 const Bu::TafGroup *Bu::TafGroup::getChildByPath(
-                const Bu::String &sPath ) const
+        const Bu::String &sPath ) const
 {
-        return getChildByPath( sPath.split('/') );
+    return getChildByPath( sPath.split('/') );
 }
 
 const Bu::TafGroup *Bu::TafGroup::getChildByPath( Bu::StrList lPath ) const
 {
-        const Bu::TafGroup *cur = this;
+    const Bu::TafGroup *cur = this;
 
-        for( Bu::StrList::const_iterator i = lPath.begin(); i; i++ )
-        {
-                cur = cur->getChild( *i );
-        }
+    for( Bu::StrList::const_iterator i = lPath.begin(); i; i++ )
+    {
+        cur = cur->getChild( *i );
+    }
 
-        return cur;
+    return cur;
 }
 
 const Bu::String &Bu::TafGroup::getByPath( const Bu::String &sPath ) const
 {
-        return getByPath( sPath.split('/') );
+    return getByPath( sPath.split('/') );
 }
 
 const Bu::String &Bu::TafGroup::getByPath( Bu::StrList lPath ) const
 {
-        const Bu::TafGroup *cur = this;
+    const Bu::TafGroup *cur = this;
 
-        for( Bu::StrList::const_iterator i = lPath.begin(); i; i++ )
-        {
-                if( !(i+1) )
-                        break;
-                cur = cur->getChild( *i );
-        }
+    for( Bu::StrList::const_iterator i = lPath.begin(); i; i++ )
+    {
+        if( !(i+1) )
+            break;
+        cur = cur->getChild( *i );
+    }
 
-        return cur->getProperty( lPath.last() );
+    return cur->getProperty( lPath.last() );
 }
 
diff --git a/src/stable/tafgroup.h b/src/stable/tafgroup.h
index 3f52ab3..a22059e 100644
--- a/src/stable/tafgroup.h
+++ b/src/stable/tafgroup.h
@@ -16,56 +16,56 @@
 
 namespace Bu
 {
-        typedef Bu::List<Bu::String> StrList;
-        class TafProperty;
-        class TafComment;
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafGroup : public TafNode
-        {
-        public:
-                typedef Bu::List<Bu::String> PropList;
-                typedef Bu::Hash<Bu::String, PropList> PropHash;
-                typedef Bu::List<class Bu::TafGroup *> GroupList;
-                typedef Bu::Hash<Bu::String, GroupList> GroupHash;
-                typedef Bu::List<class Bu::TafNode *> NodeList;
+    typedef Bu::List<Bu::String> StrList;
+    class TafProperty;
+    class TafComment;
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafGroup : public TafNode
+    {
+    public:
+        typedef Bu::List<Bu::String> PropList;
+        typedef Bu::Hash<Bu::String, PropList> PropHash;
+        typedef Bu::List<class Bu::TafGroup *> GroupList;
+        typedef Bu::Hash<Bu::String, GroupList> GroupHash;
+        typedef Bu::List<class Bu::TafNode *> NodeList;
 
-                TafGroup( const TafGroup &rSrc );
-                TafGroup( const Bu::String &sName );
-                virtual ~TafGroup();
+        TafGroup( const TafGroup &rSrc );
+        TafGroup( const Bu::String &sName );
+        virtual ~TafGroup();
 
-                const Bu::String &getName() const;
-                void setName( const Bu::String &sName );
+        const Bu::String &getName() const;
+        void setName( const Bu::String &sName );
 
-                bool hasProperty( const Bu::String &sName ) const;
-                const Bu::String &getProperty( const Bu::String &sName ) const;
-                const Bu::String &getProperty( const Bu::String &sName,
-                        const Bu::String &sDef ) const;
-                const PropList &getProperties( const Bu::String &sName ) const;
-                bool hasChild( const Bu::String &sName ) const;
-                const TafGroup *getChild( const Bu::String &sName ) const;
-                const GroupList &getChildren( const Bu::String &sName ) const;
-                TafNode *addChild( TafNode *pNode );
-                TafGroup *addChild( TafGroup *pNode );
-                TafProperty *addChild( TafProperty *pNode );
-                TafComment *addChild( TafComment *pNode );
-                TafGroup *addGroup( const Bu::String &sName );
-                TafProperty *addProperty(
-                        const Bu::String &sName, const Bu::String &sValue );
-                const NodeList &getChildren() const;
-                const TafGroup *getChildByPath( const Bu::String &sPath ) const;
-                const TafGroup *getChildByPath( StrList lPath ) const;
-                const Bu::String &getByPath( const Bu::String &sPath ) const;
-                const Bu::String &getByPath( StrList lPath ) const;
+        bool hasProperty( const Bu::String &sName ) const;
+        const Bu::String &getProperty( const Bu::String &sName ) const;
+        const Bu::String &getProperty( const Bu::String &sName,
+            const Bu::String &sDef ) const;
+        const PropList &getProperties( const Bu::String &sName ) const;
+        bool hasChild( const Bu::String &sName ) const;
+        const TafGroup *getChild( const Bu::String &sName ) const;
+        const GroupList &getChildren( const Bu::String &sName ) const;
+        TafNode *addChild( TafNode *pNode );
+        TafGroup *addChild( TafGroup *pNode );
+        TafProperty *addChild( TafProperty *pNode );
+        TafComment *addChild( TafComment *pNode );
+        TafGroup *addGroup( const Bu::String &sName );
+        TafProperty *addProperty(
+            const Bu::String &sName, const Bu::String &sValue );
+        const NodeList &getChildren() const;
+        const TafGroup *getChildByPath( const Bu::String &sPath ) const;
+        const TafGroup *getChildByPath( StrList lPath ) const;
+        const Bu::String &getByPath( const Bu::String &sPath ) const;
+        const Bu::String &getByPath( StrList lPath ) const;
 
-        private:
-                Bu::String sName;
-                PropHash hProp;
-                GroupHash hChildren;
-                NodeList lChildren;
-        };
+    private:
+        Bu::String sName;
+        PropHash hProp;
+        GroupHash hChildren;
+        NodeList lChildren;
+    };
 }
 
 #endif
diff --git a/src/stable/tafnode.cpp b/src/stable/tafnode.cpp
index 630bcce..10ba89a 100644
--- a/src/stable/tafnode.cpp
+++ b/src/stable/tafnode.cpp
@@ -10,7 +10,7 @@
 namespace Bu { subExceptionDef( TafException ) }
 
 Bu::TafNode::TafNode( NodeType eType ) :
-        eType( eType )
+    eType( eType )
 {
 }
 
@@ -20,6 +20,6 @@ Bu::TafNode::~TafNode()
 
 Bu::TafNode::NodeType Bu::TafNode::getType() const
 {
-        return eType;
+    return eType;
 }
 
diff --git a/src/stable/tafnode.h b/src/stable/tafnode.h
index 9c0e0b9..923ee24 100644
--- a/src/stable/tafnode.h
+++ b/src/stable/tafnode.h
@@ -15,30 +15,30 @@
 
 namespace Bu
 {
-        subExceptionDecl( TafException );
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafNode
-        {
-        public:
-                enum NodeType
-                {
-                        typeGroup,
-                        typeProperty,
-                        typeComment
-                };
+    subExceptionDecl( TafException );
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafNode
+    {
+    public:
+        enum NodeType
+        {
+            typeGroup,
+            typeProperty,
+            typeComment
+        };
 
-        public:
-                TafNode( NodeType eType );
-                virtual ~TafNode();
+    public:
+        TafNode( NodeType eType );
+        virtual ~TafNode();
 
-                NodeType getType() const;
+        NodeType getType() const;
 
-        private:
-                NodeType eType;
-        };
+    private:
+        NodeType eType;
+    };
 }
 
 #endif
diff --git a/src/stable/tafproperty.cpp b/src/stable/tafproperty.cpp
index 017b294..2b3e338 100644
--- a/src/stable/tafproperty.cpp
+++ b/src/stable/tafproperty.cpp
@@ -8,16 +8,16 @@
 #include "bu/tafproperty.h"
 
 Bu::TafProperty::TafProperty( const Bu::TafProperty &rSrc ) :
-        TafNode( typeProperty ),
-        sName( rSrc.sName ),
-        sValue( rSrc.sValue )
+    TafNode( typeProperty ),
+    sName( rSrc.sName ),
+    sValue( rSrc.sValue )
 {
 }
 
 Bu::TafProperty::TafProperty( const Bu::String &sName, const Bu::String &sValue ) :
-        TafNode( typeProperty ),
-        sName( sName ),
-        sValue( sValue )
+    TafNode( typeProperty ),
+    sName( sName ),
+    sValue( sValue )
 {
 }
 
@@ -27,11 +27,11 @@ Bu::TafProperty::~TafProperty()
 
 const Bu::String &Bu::TafProperty::getName() const
 {
-        return sName;
+    return sName;
 }
 
 const Bu::String &Bu::TafProperty::getValue() const
 {
-        return sValue;
+    return sValue;
 }
 
diff --git a/src/stable/tafproperty.h b/src/stable/tafproperty.h
index b7c6983..b9834e1 100644
--- a/src/stable/tafproperty.h
+++ b/src/stable/tafproperty.h
@@ -13,24 +13,24 @@
 
 namespace Bu
 {
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafProperty : public TafNode
-        {
-        public:
-                TafProperty( const Bu::TafProperty &rSrc );
-                TafProperty( const Bu::String &sName, const Bu::String &sValue );
-                virtual ~TafProperty();
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafProperty : public TafNode
+    {
+    public:
+        TafProperty( const Bu::TafProperty &rSrc );
+        TafProperty( const Bu::String &sName, const Bu::String &sValue );
+        virtual ~TafProperty();
 
-                const Bu::String &getName() const;
-                const Bu::String &getValue() const;
+        const Bu::String &getName() const;
+        const Bu::String &getValue() const;
 
-        private:
-                Bu::String sName;
-                Bu::String sValue;
-        };
+    private:
+        Bu::String sName;
+        Bu::String sValue;
+    };
 }
 
 #endif
diff --git a/src/stable/tafreader.cpp b/src/stable/tafreader.cpp
index fb17aea..f21505e 100644
--- a/src/stable/tafreader.cpp
+++ b/src/stable/tafreader.cpp
@@ -14,12 +14,12 @@
 using namespace Bu;
 
 Bu::TafReader::TafReader( Bu::Stream &sIn ) :
-        c( 0 ),
-        la( 0 ),
-        sIn( sIn ),
-        iLine( 1 ), iCol( -1 )
+    c( 0 ),
+    la( 0 ),
+    sIn( sIn ),
+    iLine( 1 ), iCol( -1 )
 {
-        next(); next();
+    next(); next();
 }
 
 Bu::TafReader::~TafReader()
@@ -29,122 +29,122 @@ Bu::TafReader::~TafReader()
 
 Bu::TafGroup *Bu::TafReader::readGroup()
 {
-        ws();
-        if( c != '{' )
-                throw TafException("%d:%d: Expected '{' got '%c'.", iLine, iCol, c );
-        next();
-        ws();
-        String sName = readStr();
-        TafGroup *pGroup = new TafGroup( sName );
-        try
-        {
-                ws();
-                if( c != ':' )
-                        throw TafException("%d:%d: Expected ':' got '%c'.",
-                                iLine, iCol, c );
-                next();
-                //printf("Node[%s]:\n", sName.getStr() );
-
-                groupContent( pGroup );
-
-                if( c != '}' )
-                        throw TafException("%d:%d: Expected '}' got '%c'.",
-                                iLine, iCol, c );
-
-                //next();
-
-                return pGroup;
-        }
-        catch(...)
-        {
-                delete pGroup;
-                throw;
-        }
+    ws();
+    if( c != '{' )
+        throw TafException("%d:%d: Expected '{' got '%c'.", iLine, iCol, c );
+    next();
+    ws();
+    String sName = readStr();
+    TafGroup *pGroup = new TafGroup( sName );
+    try
+    {
+        ws();
+        if( c != ':' )
+            throw TafException("%d:%d: Expected ':' got '%c'.",
+                iLine, iCol, c );
+        next();
+        //printf("Node[%s]:\n", sName.getStr() );
+
+        groupContent( pGroup );
+
+        if( c != '}' )
+            throw TafException("%d:%d: Expected '}' got '%c'.",
+                iLine, iCol, c );
+
+        //next();
+
+        return pGroup;
+    }
+    catch(...)
+    {
+        delete pGroup;
+        throw;
+    }
 }
 
 void Bu::TafReader::groupContent( Bu::TafGroup *pGroup )
 {
-        for(;;)
-        {
-                ws();
-                if( c == '{' )
-                {
-                        pGroup->addChild( readGroup() );
-                        next();
-                }
-                else if( c == '}' )
-                        return;
-                else if( c == '/' && la == '*' )
-                        pGroup->addChild( readComment() );
-                else if( c == '/' && la == '/' )
-                        pGroup->addChild( readComment( true ) );
-                else if( c == ':' )
-                        throw TafException("%d:%d: Encountered stray ':' in taf stream.",
-                                iLine, iCol );
-                else
-                        pGroup->addChild( readProperty() );
-        }
+    for(;;)
+    {
+        ws();
+        if( c == '{' )
+        {
+            pGroup->addChild( readGroup() );
+            next();
+        }
+        else if( c == '}' )
+            return;
+        else if( c == '/' && la == '*' )
+            pGroup->addChild( readComment() );
+        else if( c == '/' && la == '/' )
+            pGroup->addChild( readComment( true ) );
+        else if( c == ':' )
+            throw TafException("%d:%d: Encountered stray ':' in taf stream.",
+                iLine, iCol );
+        else
+            pGroup->addChild( readProperty() );
+    }
 }
 
 Bu::TafProperty *Bu::TafReader::readProperty()
 {
-        String sName = readStr();
-        ws();
-        if( c != '=' )
-        {
-                //printf("  %s (true)\n", sName.getStr() );
-                return new Bu::TafProperty( "", sName );
-        }
-        next();
-        String sValue = readStr();
-        return new Bu::TafProperty( sName, sValue );
-        //printf("  %s = %s\n", sName.getStr(), sValue.getStr() );
+    String sName = readStr();
+    ws();
+    if( c != '=' )
+    {
+        //printf("  %s (true)\n", sName.getStr() );
+        return new Bu::TafProperty( "", sName );
+    }
+    next();
+    String sValue = readStr();
+    return new Bu::TafProperty( sName, sValue );
+    //printf("  %s = %s\n", sName.getStr(), sValue.getStr() );
 }
 
 Bu::TafComment *Bu::TafReader::readComment( bool bEOL )
 {
-        String sCmnt;
-        next();
-        if( bEOL )
-        {
-                for(;;)
-                {
-                        next();
-                        if( c == '\n' && la == '\r' )
-                        {
-                                next(); next();
-                                break;
-                        }
-                        else if( c == '\n' || c == '\r' )
-                        {
-                                next();
-                                break;
-                        }
-                        sCmnt += c;
-                }
-        }
-        else
-        {
-                for(;;)
-                {
-                        next();
-                        if( c == '*' && la == '/' )
-                        {
-                                next(); next();
-                                break;
-                        }
-                        sCmnt += c;
-                }
-        }
-
-        return new TafComment( sCmnt, bEOL );
+    String sCmnt;
+    next();
+    if( bEOL )
+    {
+        for(;;)
+        {
+            next();
+            if( c == '\n' && la == '\r' )
+            {
+                next(); next();
+                break;
+            }
+            else if( c == '\n' || c == '\r' )
+            {
+                next();
+                break;
+            }
+            sCmnt += c;
+        }
+    }
+    else
+    {
+        for(;;)
+        {
+            next();
+            if( c == '*' && la == '/' )
+            {
+                next(); next();
+                break;
+            }
+            sCmnt += c;
+        }
+    }
+
+    return new TafComment( sCmnt, bEOL );
 }
 
 Bu::String Bu::TafReader::readStr()
 {
-        ws();
-        String s;
-        if( c == '"' )
+    ws();
+    String s;
+    if( c == '"' )
         {
                 next();
                 for(;;)
@@ -162,7 +162,7 @@ Bu::String Bu::TafReader::readStr()
                                         c = (unsigned char)strtol( code, NULL, 16 );
                                 }
                                 else if( c == '"' )
-                                        c = '"';
+                    c = '"';
                                 else if( c == '\\' )
                                         c = '\\';
                                 else if( c == 'n' )
@@ -174,79 +174,79 @@ Bu::String Bu::TafReader::readStr()
                                                 iLine, iCol, c );
                         }
                         else if( c == '"' )
-                                break;
-                        s += c;
-                        next();
-                }
-                next();
-        }
-        else
-        {
-                for(;;)
-                {
-                        if( isws() || c == '}' || c == '{' || c == ':' || c == '=' )
-                                break;
-                        s += c;
-                        next();
-                }
-        }
-
-        return s;
+                break;
+            s += c;
+            next();
+        }
+        next();
+    }
+    else
+    {
+        for(;;)
+        {
+            if( isws() || c == '}' || c == '{' || c == ':' || c == '=' )
+                break;
+            s += c;
+            next();
+        }
+    }
+
+    return s;
 }
 
 void Bu::TafReader::ws()
 {
-        for(;;)
-        {
-                if( !isws() )
-                        return;
+    for(;;)
+    {
+        if( !isws() )
+            return;
 
-                next();
-        }
+        next();
+    }
 }
 
 bool Bu::TafReader::isws()
 {
-        return (c == ' ' || c == '\t' || c == '\n' || c == '\r');
+    return (c == ' ' || c == '\t' || c == '\n' || c == '\r');
 }
 
 void Bu::TafReader::next()
 {
-        if( c == '\n' )
-        {
-                iLine++;
-                iCol = 1;
-        }
-        else
-                iCol++;
-        if( c == '}' )
-        {
-                rawread( &c );
-                if( c != '}' )
-                        rawread( &la );
-        }
-        else
-        {
-                c = la;
-                if( c != '}' )
-                        rawread( &la );
-        }
+    if( c == '\n' )
+    {
+        iLine++;
+        iCol = 1;
+    }
+    else
+        iCol++;
+    if( c == '}' )
+    {
+        rawread( &c );
+        if( c != '}' )
+            rawread( &la );
+    }
+    else
+    {
+        c = la;
+        if( c != '}' )
+            rawread( &la );
+    }
 }
 
 void Bu::TafReader::rawread( char *c )
 {
-        if( sIn.read( c, 1 ) < 1 )
-        {
-                if( sIn.isEos() )
-                {
-                        throw TafException("%d:%d: Premature end of stream.",
-                                iLine, iCol, c );
-                }
-                else
-                {
-                        throw TafException("%d:%d: No data read, but not end of stream?",
-                                iLine, iCol, c );
-                }
-        }
+    if( sIn.read( c, 1 ) < 1 )
+    {
+        if( sIn.isEos() )
+        {
+            throw TafException("%d:%d: Premature end of stream.",
+                iLine, iCol, c );
+        }
+        else
+        {
+            throw TafException("%d:%d: No data read, but not end of stream?",
+                iLine, iCol, c );
+        }
+    }
 }
 
diff --git a/src/stable/tafreader.h b/src/stable/tafreader.h
index 0cf00a9..b3ced1b 100644
--- a/src/stable/tafreader.h
+++ b/src/stable/tafreader.h
@@ -13,37 +13,37 @@
 
 namespace Bu
 {
-        class TafNode;
-        class TafGroup;
-        class TafProperty;
-        class TafComment;
-        class Stream;
+    class TafNode;
+    class TafGroup;
+    class TafProperty;
+    class TafComment;
+    class Stream;
 
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafReader
-        {
-        public:
-                TafReader( Bu::Stream &sIn );
-                virtual ~TafReader();
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafReader
+    {
+    public:
+        TafReader( Bu::Stream &sIn );
+        virtual ~TafReader();
 
-                Bu::TafGroup *readGroup();
+        Bu::TafGroup *readGroup();
 
-        private:
-                void groupContent( Bu::TafGroup *pNode );
-                Bu::TafProperty *readProperty();
-                Bu::TafComment *readComment( bool bEOL=false );
-                void ws();
-                bool isws();
-                void next();
-                Bu::String readStr();
-                void rawread( char *c );
-                char c, la;
-                Bu::Stream &sIn;
-                int iLine, iCol;
-        };
+    private:
+        void groupContent( Bu::TafGroup *pNode );
+        Bu::TafProperty *readProperty();
+        Bu::TafComment *readComment( bool bEOL=false );
+        void ws();
+        bool isws();
+        void next();
+        Bu::String readStr();
+        void rawread( char *c );
+        char c, la;
+        Bu::Stream &sIn;
+        int iLine, iCol;
+    };
 }
 
 #endif
diff --git a/src/stable/tafwriter.cpp b/src/stable/tafwriter.cpp
index 00d9f68..f17a237 100644
--- a/src/stable/tafwriter.cpp
+++ b/src/stable/tafwriter.cpp
@@ -9,8 +9,8 @@
 #include "bu/stream.h"
 
 Bu::TafWriter::TafWriter( Bu::Stream &sOut ) :
-        sOut( sOut ),
-        iDepth( 0 )
+    sOut( sOut ),
+    iDepth( 0 )
 {
 }
 
@@ -20,81 +20,81 @@ Bu::TafWriter::~TafWriter()
 
 void Bu::TafWriter::ident()
 {
-        for( int j = 0; j < iDepth; j++ )
-                sOut.write("    ", 4 );
+    for( int j = 0; j < iDepth; j++ )
+        sOut.write("    ", 4 );
 }
 
 void Bu::TafWriter::writeGroup( const Bu::TafGroup *pRoot )
 {
-        ident();
-        sOut.write("{", 1 );
-        if( pRoot->getName().isSet() )
-                writeString( pRoot->getName() );
-        sOut.write(":\n", 2 );
-        iDepth++;
-        const Bu::TafGroup::NodeList &nl = pRoot->getChildren();
-        for( Bu::TafGroup::NodeList::const_iterator i = nl.begin(); i != nl.end(); i++ )
-        {
-                switch( (*i)->getType() )
-                {
-                        case Bu::TafNode::typeGroup:
-                                writeGroup( (Bu::TafGroup *)(*i) );
-                                break;
+    ident();
+    sOut.write("{", 1 );
+    if( pRoot->getName().isSet() )
+        writeString( pRoot->getName() );
+    sOut.write(":\n", 2 );
+    iDepth++;
+    const Bu::TafGroup::NodeList &nl = pRoot->getChildren();
+    for( Bu::TafGroup::NodeList::const_iterator i = nl.begin(); i != nl.end(); i++ )
+    {
+        switch( (*i)->getType() )
+        {
+            case Bu::TafNode::typeGroup:
+                writeGroup( (Bu::TafGroup *)(*i) );
+                break;
 
-                        case Bu::TafNode::typeProperty:
-                                writeProperty( (Bu::TafProperty *)(*i) );
-                                break;
+            case Bu::TafNode::typeProperty:
+                writeProperty( (Bu::TafProperty *)(*i) );
+                break;
 
-                        case Bu::TafNode::typeComment:
-                                writeComment( (Bu::TafComment *)(*i) );
-                                break;
-                }
-        }
-        iDepth--;
-        ident();
-        sOut.write("}\n", 2 );
+            case Bu::TafNode::typeComment:
+                writeComment( (Bu::TafComment *)(*i) );
+                break;
+        }
+    }
+    iDepth--;
+    ident();
+    sOut.write("}\n", 2 );
 }
 
 void Bu::TafWriter::writeProperty( const Bu::TafProperty *pProp )
 {
-        ident();
-        if( !pProp->getName().isEmpty() )
-        {
-                writeString( pProp->getName() );
-                sOut.write("=", 1 );
-                writeString( pProp->getValue() );
-        }
-        else
-        {
-                writeString( pProp->getValue() );
-        }
-        sOut.write("\n", 1 );
+    ident();
+    if( !pProp->getName().isEmpty() )
+    {
+        writeString( pProp->getName() );
+        sOut.write("=", 1 );
+        writeString( pProp->getValue() );
+    }
+    else
+    {
+        writeString( pProp->getValue() );
+    }
+    sOut.write("\n", 1 );
 }
 
 void Bu::TafWriter::writeComment( const Bu::TafComment *pComment )
 {
-        ident();
-        if( pComment->isEOLStyle() )
-        {
-                sOut.write("//", 2 );
-                sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
-                sOut.write("\n", 1 );
-        }
-        else
-        {
-                sOut.write("/*", 2 );
-                sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
-                sOut.write("*/ ", 3 );
-        }
+    ident();
+    if( pComment->isEOLStyle() )
+    {
+        sOut.write("//", 2 );
+        sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
+        sOut.write("\n", 1 );
+    }
+    else
+    {
+        sOut.write("/*", 2 );
+        sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
+        sOut.write("*/ ", 3 );
+    }
 }
 
 void Bu::TafWriter::writeString( const Bu::String &str )
 {
-        sOut.write("\"", 1 );
+    sOut.write("\"", 1 );
         for( Bu::String::const_iterator s = str.begin(); s != str.end(); s++ )
         {
                 if( *s == '\"' )
-                        sOut.write("\\\"", 2 );
+            sOut.write("\\\"", 2 );
                 else if( *s == '\\' )
                         sOut.write("\\\\", 2 );
                 else if( *s < 32 || *s > 126 )
diff --git a/src/stable/tafwriter.h b/src/stable/tafwriter.h
index 7e43d64..48787ab 100644
--- a/src/stable/tafwriter.h
+++ b/src/stable/tafwriter.h
@@ -14,32 +14,32 @@
 
 namespace Bu
 {
-        class Stream;
-        class TafNode;
-        class TafGroup;
-        class TafProperty;
-        class TafComment;
-
-        /**
-         *
-         *@ingroup Taf
-         */
-        class TafWriter
-        {
-        public:
-                TafWriter( Bu::Stream &sOut );
-                virtual ~TafWriter();
-
-                void writeGroup( const Bu::TafGroup *pRoot );
-
-        private:
-                void writeProperty( const Bu::TafProperty *pProp );
-                void writeComment( const Bu::TafComment *pComment );
-                void writeString( const Bu::String &str );
-                void ident();
-                Bu::Stream &sOut;
-                int iDepth;
-        };
+    class Stream;
+    class TafNode;
+    class TafGroup;
+    class TafProperty;
+    class TafComment;
+
+    /**
+     *
+     *@ingroup Taf
+     */
+    class TafWriter
+    {
+    public:
+        TafWriter( Bu::Stream &sOut );
+        virtual ~TafWriter();
+
+        void writeGroup( const Bu::TafGroup *pRoot );
+
+    private:
+        void writeProperty( const Bu::TafProperty *pProp );
+        void writeComment( const Bu::TafComment *pComment );
+        void writeString( const Bu::String &str );
+        void ident();
+        Bu::Stream &sOut;
+        int iDepth;
+    };
 }
 
 #endif
diff --git a/src/stable/tcpserversocket.cpp b/src/stable/tcpserversocket.cpp
index 91da199..aed7699 100644
--- a/src/stable/tcpserversocket.cpp
+++ b/src/stable/tcpserversocket.cpp
@@ -28,230 +28,230 @@
 namespace Bu { subExceptionDef( TcpServerSocketException ) }
 
 Bu::TcpServerSocket::TcpServerSocket( int nPort, int nPoolSize ) :
-        nPort( nPort )
+    nPort( nPort )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
-        
-        /* Create the socket and set it up to accept connections. */
-        struct sockaddr_in name;
+    
+    /* Create the socket and set it up to accept connections. */
+    struct sockaddr_in name;
 
-        /* Give the socket a name. */
-        name.sin_family = AF_INET;
-        name.sin_port = bu_htons( nPort );
+    /* Give the socket a name. */
+    name.sin_family = AF_INET;
+    name.sin_port = bu_htons( nPort );
 
-        // I think this specifies who we will accept connections from,
-        // a good thing to make configurable later on
-        name.sin_addr.s_addr = bu_htonl( INADDR_ANY );
+    // I think this specifies who we will accept connections from,
+    // a good thing to make configurable later on
+    name.sin_addr.s_addr = bu_htonl( INADDR_ANY );
 
-        startServer( name, nPoolSize );
+    startServer( name, nPoolSize );
 }
 
 Bu::TcpServerSocket::TcpServerSocket(const String &sAddr,int nPort, int nPoolSize) :
-        nPort( nPort )
+    nPort( nPort )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
 
-        /* Create the socket and set it up to accept connections. */
-        struct sockaddr_in name;
+    /* Create the socket and set it up to accept connections. */
+    struct sockaddr_in name;
 
-        /* Give the socket a name. */
-        name.sin_family = AF_INET;
+    /* Give the socket a name. */
+    name.sin_family = AF_INET;
 
-        name.sin_port = bu_htons( nPort );
+    name.sin_port = bu_htons( nPort );
 
 #ifdef WIN32
-        name.sin_addr.s_addr = bu_inet_addr( sAddr.getStr() );
+    name.sin_addr.s_addr = bu_inet_addr( sAddr.getStr() );
 #else
-        inet_aton( sAddr.getStr(), &name.sin_addr );
+    inet_aton( sAddr.getStr(), &name.sin_addr );
 #endif
 
-        startServer( name, nPoolSize );
+    startServer( name, nPoolSize );
 }
 
 Bu::TcpServerSocket::TcpServerSocket( socket_t nServer, bool bInit, int nPoolSize ) :
-        nServer( nServer ),
-        nPort( 0 )
+    nServer( nServer ),
+    nPort( 0 )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
-        
-        if( bInit )
-        {
-                struct sockaddr name;
-                socklen_t namelen = sizeof(name);
-                getpeername( nServer, &name, &namelen );
-
-                initServer( *((sockaddr_in *)&name), nPoolSize );
-        }
-        else
-        {
-                FD_ZERO( &fdActive );
-                FD_SET( nServer, &fdActive );
-        }
+    
+    if( bInit )
+    {
+        struct sockaddr name;
+        socklen_t namelen = sizeof(name);
+        getpeername( nServer, &name, &namelen );
+
+        initServer( *((sockaddr_in *)&name), nPoolSize );
+    }
+    else
+    {
+        FD_ZERO( &fdActive );
+        FD_SET( nServer, &fdActive );
+    }
 }
 
 Bu::TcpServerSocket::TcpServerSocket( const TcpServerSocket &rSrc )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
 
-        nServer = dup( rSrc.nServer );
-        nPort = rSrc.nPort;
-        FD_ZERO( &fdActive );
-        FD_SET( nServer, &fdActive );
+    nServer = dup( rSrc.nServer );
+    nPort = rSrc.nPort;
+    FD_ZERO( &fdActive );
+    FD_SET( nServer, &fdActive );
 }
 
 Bu::TcpServerSocket::~TcpServerSocket()
 {
 #ifdef WIN32
-        if( nServer != INVALID_SOCKET )
+    if( nServer != INVALID_SOCKET )
 #else
-        if( nServer > -1 )
+    if( nServer > -1 )
 #endif
-                ::close( nServer );
+        ::close( nServer );
 }
 
 void Bu::TcpServerSocket::startServer( struct sockaddr_in &name, int nPoolSize )
 {
-        /* Create the socket. */
-        nServer = bu_socket( PF_INET, SOCK_STREAM, 0 );
+    /* Create the socket. */
+    nServer = bu_socket( PF_INET, SOCK_STREAM, 0 );
 
 #ifdef WIN32
-        if( nServer == INVALID_SOCKET )
+    if( nServer == INVALID_SOCKET )
 #else
-        if( nServer < 0 )
+    if( nServer < 0 )
 #endif
-        {
-                throw Bu::TcpServerSocketException("Couldn't create a listen socket.");
-        }
-        
-        int opt = 1;
-        bu_setsockopt(
-                        nServer,
-                        SOL_SOCKET,
-                        SO_REUSEADDR,
-                        (char *)&opt,
-                        sizeof( opt )
-                        );
-
-        initServer( name, nPoolSize );
+    {
+        throw Bu::TcpServerSocketException("Couldn't create a listen socket.");
+    }
+    
+    int opt = 1;
+    bu_setsockopt(
+            nServer,
+            SOL_SOCKET,
+            SO_REUSEADDR,
+            (char *)&opt,
+            sizeof( opt )
+            );
+
+    initServer( name, nPoolSize );
 }
 
 void Bu::TcpServerSocket::initServer( struct sockaddr_in &name, int nPoolSize )
 {
-        if( bu_bind( nServer, (struct sockaddr *) &name, sizeof(name) ) < 0 )
-        {
-                throw Bu::TcpServerSocketException("Couldn't bind to the listen socket.");
-        }
-
-        if( bu_listen( nServer, nPoolSize ) < 0 )
-        {
-                throw Bu::TcpServerSocketException(
-                        "Couldn't begin listening to the server socket."
-                        );
-        }
-
-        FD_ZERO( &fdActive );
-        /* Initialize the set of active sockets. */
-        FD_SET( nServer, &fdActive );
+    if( bu_bind( nServer, (struct sockaddr *) &name, sizeof(name) ) < 0 )
+    {
+        throw Bu::TcpServerSocketException("Couldn't bind to the listen socket.");
+    }
+
+    if( bu_listen( nServer, nPoolSize ) < 0 )
+    {
+        throw Bu::TcpServerSocketException(
+            "Couldn't begin listening to the server socket."
+            );
+    }
+
+    FD_ZERO( &fdActive );
+    /* Initialize the set of active sockets. */
+    FD_SET( nServer, &fdActive );
 }
 
 int Bu::TcpServerSocket::getSocket()
 {
-        return nServer;
+    return nServer;
 }
 
 int Bu::TcpServerSocket::accept( int nTimeoutSec, int nTimeoutUSec )
 {
-        fd_set fdRead = fdActive;
+    fd_set fdRead = fdActive;
 
-        struct timeval xT;
+    struct timeval xT;
 
-        xT.tv_sec = nTimeoutSec;
-        xT.tv_usec = nTimeoutUSec;      
+    xT.tv_sec = nTimeoutSec;
+    xT.tv_usec = nTimeoutUSec;  
 
-        if( TEMP_FAILURE_RETRY(
-                bu_select( nServer+1, &fdRead, NULL, NULL, &xT )) < 0 )
-        {
-                throw Bu::TcpServerSocketException(
-                        "Error scanning for new connections: %s", strerror( errno )
-                        );
-        }
+    if( TEMP_FAILURE_RETRY(
+        bu_select( nServer+1, &fdRead, NULL, NULL, &xT )) < 0 )
+    {
+        throw Bu::TcpServerSocketException(
+            "Error scanning for new connections: %s", strerror( errno )
+            );
+    }
 
-        if( FD_ISSET( nServer, &fdRead ) )
-        {
-                struct sockaddr_in clientname;
-                socklen_t size;
-                int nClient;
+    if( FD_ISSET( nServer, &fdRead ) )
+    {
+        struct sockaddr_in clientname;
+        socklen_t size;
+        int nClient;
 
-                size = sizeof( clientname );
+        size = sizeof( clientname );
 #ifdef WIN32
-                nClient = bu_accept( nServer, (struct sockaddr *)&clientname, &size);
+        nClient = bu_accept( nServer, (struct sockaddr *)&clientname, &size);
 #else /* not-WIN32 */
 #ifdef __CYGWIN__
-                nClient = ::accept( nServer, (struct sockaddr *)&clientname,
-                                (int *)&size
-                                );
+        nClient = ::accept( nServer, (struct sockaddr *)&clientname,
+                (int *)&size
+                );
 #else /* not-cygwin */
 #ifdef __APPLE__
-                nClient = ::accept( nServer, (struct sockaddr *)&clientname, (socklen_t*)&size );
+        nClient = ::accept( nServer, (struct sockaddr *)&clientname, (socklen_t*)&size );
 #else /* linux */
-                nClient = ::accept( nServer, (struct sockaddr *)&clientname, &size );
+        nClient = ::accept( nServer, (struct sockaddr *)&clientname, &size );
 #endif /* __APPLE__ */
 #endif /* __CYGWIN__ */
 #endif /* WIN32 */
-                if( nClient < 0 )
-                {
-                        throw Bu::TcpServerSocketException(
-                                "Error accepting a new connection: %s", strerror( errno )
-                                );
-                }
+        if( nClient < 0 )
+        {
+            throw Bu::TcpServerSocketException(
+                "Error accepting a new connection: %s", strerror( errno )
+                );
+        }
 
 #ifndef WIN32
-                char tmpa[20];
-                inet_ntop( AF_INET, (void *)&clientname.sin_addr, tmpa, 20 );
-                //"New connection from host %s, port %hd.",
-                //  tmpa, ntohs (clientname.sin_port) );
+        char tmpa[20];
+        inet_ntop( AF_INET, (void *)&clientname.sin_addr, tmpa, 20 );
+        //"New connection from host %s, port %hd.",
+        //  tmpa, ntohs (clientname.sin_port) );
 #endif
-                
-                {
+        
+        {
 #ifndef WIN32
-                        int flags;
-                        flags = fcntl( nClient, F_GETFL, 0 );
-                        flags |= O_NONBLOCK;
-                        if( fcntl( nClient, F_SETFL, flags ) < 0)
-                        {
-                                throw Bu::TcpServerSocketException(
-                                        "Error setting option on client socket: %s",
-                                        strerror( errno )
-                                        );
-                        }
+            int flags;
+            flags = fcntl( nClient, F_GETFL, 0 );
+            flags |= O_NONBLOCK;
+            if( fcntl( nClient, F_SETFL, flags ) < 0)
+            {
+                throw Bu::TcpServerSocketException(
+                    "Error setting option on client socket: %s",
+                    strerror( errno )
+                    );
+            }
 #else
-                        //-------------------------
-                        // Set the socket I/O mode: In this case FIONBIO
-                        // enables or disables the blocking mode for the 
-                        // socket based on the numerical value of iMode.
-                        // If iMode = 0, blocking is enabled; 
-                        // If iMode != 0, non-blocking mode is enabled.
-                        u_long iMode = 1;
-                        bu_ioctlsocket(nClient, FIONBIO, &iMode);                       
+            //-------------------------
+            // Set the socket I/O mode: In this case FIONBIO
+            // enables or disables the blocking mode for the 
+            // socket based on the numerical value of iMode.
+            // If iMode = 0, blocking is enabled; 
+            // If iMode != 0, non-blocking mode is enabled.
+            u_long iMode = 1;
+            bu_ioctlsocket(nClient, FIONBIO, &iMode);           
 #endif
-                }
+        }
 
-                return nClient;
-        }
+        return nClient;
+    }
 
-        return -1;
+    return -1;
 }
 
 int Bu::TcpServerSocket::getPort()
 {
-        return nPort;
+    return nPort;
 }
 
diff --git a/src/stable/tcpserversocket.h b/src/stable/tcpserversocket.h
index 9776668..fd1d547 100644
--- a/src/stable/tcpserversocket.h
+++ b/src/stable/tcpserversocket.h
@@ -20,46 +20,46 @@
 
 namespace Bu
 {
-        subExceptionDecl( TcpServerSocketException );
+    subExceptionDecl( TcpServerSocketException );
 
-        /**
-         * A single tcp/ip server socket.  When created the server socket will bind
-         * to the specified interface and port, and immediately begin listening for
-         * connections.  When connections come in they are pooled by the networking
-         * drivers in the kernel until they are accepted, this means that failure
-         * to keep space in the connection pool will result in connection refusals.
-         *
-         * Although the accept function returns an integral file descriptor, it is
-         * designed to be used with the Socket class.
-         *
-         *@ingroup Serving
-         */
-        class TcpServerSocket
-        {
-        public:
+    /**
+     * A single tcp/ip server socket.  When created the server socket will bind
+     * to the specified interface and port, and immediately begin listening for
+     * connections.  When connections come in they are pooled by the networking
+     * drivers in the kernel until they are accepted, this means that failure
+     * to keep space in the connection pool will result in connection refusals.
+     *
+     * Although the accept function returns an integral file descriptor, it is
+     * designed to be used with the Socket class.
+     *
+     *@ingroup Serving
+     */
+    class TcpServerSocket
+    {
+    public:
 #ifdef WIN32
-                typedef unsigned int socket_t;
+        typedef unsigned int socket_t;
 #else
-                typedef int socket_t;
+        typedef int socket_t;
 #endif
-                TcpServerSocket( int nPort, int nPoolSize=40 );
-                TcpServerSocket( const String &sAddr, int nPort, int nPoolSize=40 );
-                TcpServerSocket( socket_t nSocket, bool bInit, int nPoolSize=40 );
-                TcpServerSocket( const TcpServerSocket &rSrc );
-                virtual ~TcpServerSocket();
+        TcpServerSocket( int nPort, int nPoolSize=40 );
+        TcpServerSocket( const String &sAddr, int nPort, int nPoolSize=40 );
+        TcpServerSocket( socket_t nSocket, bool bInit, int nPoolSize=40 );
+        TcpServerSocket( const TcpServerSocket &rSrc );
+        virtual ~TcpServerSocket();
 
-                int accept( int nTimeoutSec=0, int nTimeoutUSec=0 );
-                int getSocket();
-                int getPort();
+        int accept( int nTimeoutSec=0, int nTimeoutUSec=0 );
+        int getSocket();
+        int getPort();
 
-        private:
-                void startServer( struct sockaddr_in &name, int nPoolSize );
-                void initServer( struct sockaddr_in &name, int nPoolSize );
+    private:
+        void startServer( struct sockaddr_in &name, int nPoolSize );
+        void initServer( struct sockaddr_in &name, int nPoolSize );
 
-                fd_set fdActive;
-                socket_t nServer;
-                int nPort;
-        };
+        fd_set fdActive;
+        socket_t nServer;
+        int nPort;
+    };
 }
 
 #endif
diff --git a/src/stable/tcpsocket.cpp b/src/stable/tcpsocket.cpp
index fa79a36..b77f439 100644
--- a/src/stable/tcpsocket.cpp
+++ b/src/stable/tcpsocket.cpp
@@ -32,392 +32,392 @@
 namespace Bu { subExceptionDef( TcpSocketException ) }
 
 Bu::TcpSocket::TcpSocket( handle nTcpSocket ) :
-        nTcpSocket( nTcpSocket ),
-        bActive( true ),
-        bBlocking( true )
+    nTcpSocket( nTcpSocket ),
+    bActive( true ),
+    bBlocking( true )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
-        setAddress();
+    setAddress();
 }
 
 Bu::TcpSocket::TcpSocket( const Bu::String &sAddr, int nPort, int nTimeout,
-                bool bBlocking ) :
-        nTcpSocket( 0 ),
-        bActive( false ),
-        bBlocking( true )
+        bool bBlocking ) :
+    nTcpSocket( 0 ),
+    bActive( false ),
+    bBlocking( true )
 {
 #ifdef WIN32
-        Bu::Winsock2::getInstance();
+    Bu::Winsock2::getInstance();
 #endif
 
-        /* Create the socket. */
-        nTcpSocket = bu_socket( PF_INET, SOCK_STREAM, 0 );
-        
+    /* Create the socket. */
+    nTcpSocket = bu_socket( PF_INET, SOCK_STREAM, 0 );
+    
 #ifdef WIN32
-        if( nTcpSocket == INVALID_SOCKET )
+    if( nTcpSocket == INVALID_SOCKET )
 #else
-        if( nTcpSocket < 0 )
+    if( nTcpSocket < 0 )
 #endif
-        {
-                throw ExceptionBase("Couldn't create socket.\n");
-        }
+    {
+        throw ExceptionBase("Couldn't create socket.\n");
+    }
 
-        setBlocking( false );
+    setBlocking( false );
      
-        /* Connect to the server. */
-        //printf("Resolving hostname (%s)...\n", sAddr );
-        {
-                struct addrinfo *pAddr = NULL;
-                struct addrinfo aiHints;
-                memset( &aiHints, 0, sizeof(addrinfo) );
-                aiHints.ai_flags = AI_CANONNAME;
-                aiHints.ai_family = AF_INET;
-                aiHints.ai_socktype = SOCK_STREAM;
-                char ibuf[10]; 
-                sprintf( ibuf, "%d", nPort );
+    /* Connect to the server. */
+    //printf("Resolving hostname (%s)...\n", sAddr );
+    {
+        struct addrinfo *pAddr = NULL;
+        struct addrinfo aiHints;
+        memset( &aiHints, 0, sizeof(addrinfo) );
+        aiHints.ai_flags = AI_CANONNAME;
+        aiHints.ai_family = AF_INET;
+        aiHints.ai_socktype = SOCK_STREAM;
+        char ibuf[10]; 
+        sprintf( ibuf, "%d", nPort );
      
-                int ret;
-                if( (ret = bu_getaddrinfo(
-                        sAddr.getStr(), ibuf, &aiHints, &pAddr )) != 0 )
-                {
-                        close();
-                        throw Bu::TcpSocketException("Couldn't resolve hostname %s (%s).\n",
-                                sAddr.getStr(), bu_gai_strerror(ret));
-                }
-
-                bu_connect(
-                        nTcpSocket,
-                        pAddr->ai_addr,
-                        pAddr->ai_addrlen
-                        );
-
-                sAddress = pAddr->ai_canonname;
-
-                bu_freeaddrinfo( pAddr );
-        }
-
-        bActive = true;
-
-        if( nTimeout > 0 )
-        {
-                fd_set rfds, wfds, efds;
-                int retval;
-                
-                FD_ZERO(&rfds);
-                FD_SET(nTcpSocket, &rfds);
-                FD_ZERO(&wfds);
-                FD_SET(nTcpSocket, &wfds);
-                FD_ZERO(&efds);
-                FD_SET(nTcpSocket, &efds);
-
-                struct timeval tv;
-                tv.tv_sec = nTimeout;
-                tv.tv_usec = 0;
-                
-                retval = bu_select( nTcpSocket+1, &rfds, &wfds, &efds, &tv );
-
-                if( retval == 0 )
-                {
-                        close();
-                        throw ExceptionBase("Connection timeout.\n");
-                }
-                read( NULL, 0 ); // See if we can get any errors out of the way early.
-        }
-
-        if( bBlocking )
-                setBlocking( bBlocking );
+        int ret;
+        if( (ret = bu_getaddrinfo(
+            sAddr.getStr(), ibuf, &aiHints, &pAddr )) != 0 )
+        {
+            close();
+            throw Bu::TcpSocketException("Couldn't resolve hostname %s (%s).\n",
+                sAddr.getStr(), bu_gai_strerror(ret));
+        }
+
+        bu_connect(
+            nTcpSocket,
+            pAddr->ai_addr,
+            pAddr->ai_addrlen
+            );
+
+        sAddress = pAddr->ai_canonname;
+
+        bu_freeaddrinfo( pAddr );
+    }
+
+    bActive = true;
+
+    if( nTimeout > 0 )
+    {
+        fd_set rfds, wfds, efds;
+        int retval;
+        
+        FD_ZERO(&rfds);
+        FD_SET(nTcpSocket, &rfds);
+        FD_ZERO(&wfds);
+        FD_SET(nTcpSocket, &wfds);
+        FD_ZERO(&efds);
+        FD_SET(nTcpSocket, &efds);
+
+        struct timeval tv;
+        tv.tv_sec = nTimeout;
+        tv.tv_usec = 0;
+        
+        retval = bu_select( nTcpSocket+1, &rfds, &wfds, &efds, &tv );
+
+        if( retval == 0 )
+        {
+            close();
+            throw ExceptionBase("Connection timeout.\n");
+        }
+        read( NULL, 0 ); // See if we can get any errors out of the way early.
+    }
+
+    if( bBlocking )
+        setBlocking( bBlocking );
 }
 
 Bu::TcpSocket::~TcpSocket()
 {
-        close();
+    close();
 }
 
 void Bu::TcpSocket::close()
 {
-        if( bActive )
-        {
+    if( bActive )
+    {
 #ifndef WIN32
-                fsync( nTcpSocket );
+        fsync( nTcpSocket );
 #endif
 #ifdef WIN32
  #ifndef SHUT_RDWR
   #define SHUT_RDWR (SD_BOTH)
  #endif
 #endif
-                bu_shutdown( nTcpSocket, SHUT_RDWR );
-                ::close( nTcpSocket );
-        }
-        bActive = false;
+        bu_shutdown( nTcpSocket, SHUT_RDWR );
+        ::close( nTcpSocket );
+    }
+    bActive = false;
 }
 
 Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes )
 {
-        fd_set rfds;
-        FD_ZERO(&rfds);
-        FD_SET(nTcpSocket, &rfds);
-        struct timeval tv = {0, 0};
-        if( bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv ) < 0 )
-        {
-                int iErr = errno;
-                close();
-                throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
-        }
-        if( FD_ISSET( nTcpSocket, &rfds ) || bBlocking )
-        {
-                int nRead = TEMP_FAILURE_RETRY( 
-                        bu_recv( nTcpSocket, (char *) pBuf, nBytes, 0 ) );
-                if( nRead == 0 && nBytes > 0 )
-                {
-                        close();
-                        throw TcpSocketException( TcpSocketException::cClosed, "TcpSocket closed.");
-                }
-                if( nRead < 0 )
-                {
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    FD_SET(nTcpSocket, &rfds);
+    struct timeval tv = {0, 0};
+    if( bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv ) < 0 )
+    {
+        int iErr = errno;
+        close();
+        throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
+    }
+    if( FD_ISSET( nTcpSocket, &rfds ) || bBlocking )
+    {
+        int nRead = TEMP_FAILURE_RETRY( 
+            bu_recv( nTcpSocket, (char *) pBuf, nBytes, 0 ) );
+        if( nRead == 0 && nBytes > 0 )
+        {
+            close();
+            throw TcpSocketException( TcpSocketException::cClosed, "TcpSocket closed.");
+        }
+        if( nRead < 0 )
+        {
 #ifdef WIN32
-                        int iWSAError = bu_WSAGetLastError();
-                        if( iWSAError == WSAEWOULDBLOCK )
-                                return 0;
+            int iWSAError = bu_WSAGetLastError();
+            if( iWSAError == WSAEWOULDBLOCK )
+                return 0;
 #else
-                        if( errno == ENETRESET || errno == ECONNRESET )
-                        {
-                                close();
-                                throw TcpSocketException( TcpSocketException::cClosed,
-                                        strerror(errno) );
-                        }
-                        if( errno == EAGAIN )
-                                return 0;
-                        int iErr = errno;
-                        close();
-                        throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
+            if( errno == ENETRESET || errno == ECONNRESET )
+            {
+                close();
+                throw TcpSocketException( TcpSocketException::cClosed,
+                    strerror(errno) );
+            }
+            if( errno == EAGAIN )
+                return 0;
+            int iErr = errno;
+            close();
+            throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
 #endif
-                }
-                return nRead;
-        }
-        return 0;
+        }
+        return nRead;
+    }
+    return 0;
 }
 
 Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes,
-                uint32_t nSec, uint32_t nUSec )
+        uint32_t nSec, uint32_t nUSec )
 {
-        struct timeval tv;
-        Bu::size nRead = 0;
-        
-        fd_set rfds;
-        FD_ZERO(&rfds);
-        FD_SET(nTcpSocket, &rfds);
+    struct timeval tv;
+    Bu::size nRead = 0;
+    
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    FD_SET(nTcpSocket, &rfds);
 
 #ifdef WIN32
-        DWORD dwStart = GetTickCount();
-        uint64_t uOver = dwStart + ((nUSec / 1000) * (nSec * 1000));
-        DWORD dwEnd = uOver>4294967295U?uOver-4294967295U:uOver;
+    DWORD dwStart = GetTickCount();
+    uint64_t uOver = dwStart + ((nUSec / 1000) * (nSec * 1000));
+    DWORD dwEnd = uOver>4294967295U?uOver-4294967295U:uOver;
 #else
-        struct timeval nt, ct;
-        gettimeofday( &nt, NULL );
-        nt.tv_sec += nSec;
-        nt.tv_usec += nUSec;
+    struct timeval nt, ct;
+    gettimeofday( &nt, NULL );
+    nt.tv_sec += nSec;
+    nt.tv_usec += nUSec;
 #endif
 
-        for(;;)
-        {
-                tv.tv_sec = nSec;
-                tv.tv_usec = nUSec;
-                bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
-                nRead += read( ((char *)pBuf)+nRead, nBytes-nRead );
-                if( nRead >= nBytes )
-                        break;
+    for(;;)
+    {
+        tv.tv_sec = nSec;
+        tv.tv_usec = nUSec;
+        bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
+        nRead += read( ((char *)pBuf)+nRead, nBytes-nRead );
+        if( nRead >= nBytes )
+            break;
 #ifdef WIN32
-                DWORD dwNow = GetTickCount();
-                if( dwNow > dwEnd )
-                        break;
+        DWORD dwNow = GetTickCount();
+        if( dwNow > dwEnd )
+            break;
 #else
-                gettimeofday( &ct, NULL );
-                if( (ct.tv_sec > nt.tv_sec) ||
-                        (ct.tv_sec == nt.tv_sec &&
-                        ct.tv_usec >= nt.tv_usec) )
-                        break;
+        gettimeofday( &ct, NULL );
+        if( (ct.tv_sec > nt.tv_sec) ||
+            (ct.tv_sec == nt.tv_sec &&
+            ct.tv_usec >= nt.tv_usec) )
+            break;
 #endif
-        }
-        return nRead;
+    }
+    return nRead;
 }
 
 Bu::size Bu::TcpSocket::write( const void *pBuf, Bu::size nBytes )
 {
 //#ifdef WIN32
-        int nWrote = TEMP_FAILURE_RETRY( 
-                bu_send( nTcpSocket, (const char *) pBuf, nBytes, 0 ) );
+    int nWrote = TEMP_FAILURE_RETRY( 
+        bu_send( nTcpSocket, (const char *) pBuf, nBytes, 0 ) );
 //#else
-//      int nWrote = TEMP_FAILURE_RETRY( ::write( nTcpSocket, pBuf, nBytes ) );
+//  int nWrote = TEMP_FAILURE_RETRY( ::write( nTcpSocket, pBuf, nBytes ) );
 //#endif
-        if( nWrote < 0 )
-        {
+    if( nWrote < 0 )
+    {
 #ifdef WIN32
-                int iWSAError = bu_WSAGetLastError();
-                if( iWSAError == WSAEWOULDBLOCK )
-                        return 0;
+        int iWSAError = bu_WSAGetLastError();
+        if( iWSAError == WSAEWOULDBLOCK )
+            return 0;
 #else
-                if( errno == EAGAIN ) return 0;
+        if( errno == EAGAIN ) return 0;
 #endif
-                throw TcpSocketException( TcpSocketException::cWrite, strerror(errno) );
-        }
-        return nWrote;
+        throw TcpSocketException( TcpSocketException::cWrite, strerror(errno) );
+    }
+    return nWrote;
 }
 
 Bu::size Bu::TcpSocket::write( const void *pBuf, Bu::size nBytes, uint32_t nSec, uint32_t nUSec )
 {
-        struct timeval tv;
-        Bu::size nWrote = 0;
-        
-        fd_set wfds;
-        FD_ZERO(&wfds);
-        FD_SET(nTcpSocket, &wfds);
+    struct timeval tv;
+    Bu::size nWrote = 0;
+    
+    fd_set wfds;
+    FD_ZERO(&wfds);
+    FD_SET(nTcpSocket, &wfds);
 
 #ifdef WIN32
-        DWORD dwStart = GetTickCount();
-        uint64_t uOver = dwStart + ((nUSec / 1000) * (nSec * 1000));
-        DWORD dwEnd = uOver>4294967295U?uOver-4294967295U:uOver;
+    DWORD dwStart = GetTickCount();
+    uint64_t uOver = dwStart + ((nUSec / 1000) * (nSec * 1000));
+    DWORD dwEnd = uOver>4294967295U?uOver-4294967295U:uOver;
 #else
-        struct timeval nt, ct;
-        gettimeofday( &nt, NULL );
-        nt.tv_sec += nSec;
-        nt.tv_usec += nUSec;
+    struct timeval nt, ct;
+    gettimeofday( &nt, NULL );
+    nt.tv_sec += nSec;
+    nt.tv_usec += nUSec;
 #endif
 
-        for(;;)
-        {
-                tv.tv_sec = nSec;
-                tv.tv_usec = nUSec;
-                bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
-                nWrote += write( ((char *)pBuf)+nWrote, nBytes-nWrote );
-                if( nWrote >= nBytes )
-                        break;
+    for(;;)
+    {
+        tv.tv_sec = nSec;
+        tv.tv_usec = nUSec;
+        bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
+        nWrote += write( ((char *)pBuf)+nWrote, nBytes-nWrote );
+        if( nWrote >= nBytes )
+            break;
 #ifdef WIN32
-                DWORD dwNow = GetTickCount();
-                if( dwNow > dwEnd )
-                        break;
+        DWORD dwNow = GetTickCount();
+        if( dwNow > dwEnd )
+            break;
 #else
-                gettimeofday( &ct, NULL );
-                if( (ct.tv_sec > nt.tv_sec) ||
-                        (ct.tv_sec == nt.tv_sec &&
-                        ct.tv_usec >= nt.tv_usec) )
-                        break;
+        gettimeofday( &ct, NULL );
+        if( (ct.tv_sec > nt.tv_sec) ||
+            (ct.tv_sec == nt.tv_sec &&
+            ct.tv_usec >= nt.tv_usec) )
+            break;
 #endif
-        }
-        return nWrote;
+    }
+    return nWrote;
 }
 
 Bu::size Bu::TcpSocket::tell()
 {
-        throw UnsupportedException();
+    throw UnsupportedException();
 }
 
 void Bu::TcpSocket::seek( Bu::size )
 {
-        throw UnsupportedException();
+    throw UnsupportedException();
 }
 
 void Bu::TcpSocket::setPos( Bu::size )
 {
-        throw UnsupportedException();
+    throw UnsupportedException();
 }
 
 void Bu::TcpSocket::setPosEnd( Bu::size )
 {
-        throw UnsupportedException();
+    throw UnsupportedException();
 }
 
 bool Bu::TcpSocket::isEos()
 {
-        return !bActive;
+    return !bActive;
 }
 
 bool Bu::TcpSocket::canRead()
 {
-        fd_set rfds;
-        FD_ZERO(&rfds);
-        FD_SET(nTcpSocket, &rfds);
-        struct timeval tv = { 0, 0 };
-        int retval = bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
-        if( retval == -1 )
-                throw TcpSocketException(
-                        TcpSocketException::cBadRead,
-                        "Bad Read error"
-                        );
-
-        if( !FD_ISSET( nTcpSocket, &rfds ) )
-                return false;
-        return true;
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    FD_SET(nTcpSocket, &rfds);
+    struct timeval tv = { 0, 0 };
+    int retval = bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
+    if( retval == -1 )
+        throw TcpSocketException(
+            TcpSocketException::cBadRead,
+            "Bad Read error"
+            );
+
+    if( !FD_ISSET( nTcpSocket, &rfds ) )
+        return false;
+    return true;
 }
 
 bool Bu::TcpSocket::canWrite()
 {
-        fd_set wfds;
-        FD_ZERO(&wfds);
-        FD_SET(nTcpSocket, &wfds);
-        struct timeval tv = { 0, 0 };
-        int retval = bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
-        if( retval == -1 )
-                throw TcpSocketException(
-                        TcpSocketException::cBadRead,
-                        "Bad Read error"
-                        );
-        if( !FD_ISSET( nTcpSocket, &wfds ) )
-                return false;
-        return true;
+    fd_set wfds;
+    FD_ZERO(&wfds);
+    FD_SET(nTcpSocket, &wfds);
+    struct timeval tv = { 0, 0 };
+    int retval = bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
+    if( retval == -1 )
+        throw TcpSocketException(
+            TcpSocketException::cBadRead,
+            "Bad Read error"
+            );
+    if( !FD_ISSET( nTcpSocket, &wfds ) )
+        return false;
+    return true;
 }
 
 bool Bu::TcpSocket::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::TcpSocket::isWritable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::TcpSocket::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::TcpSocket::isBlocking()
 {
 #ifndef WIN32
-        return ((fcntl( nTcpSocket, F_GETFL, 0 ) & O_NONBLOCK) != O_NONBLOCK);
+    return ((fcntl( nTcpSocket, F_GETFL, 0 ) & O_NONBLOCK) != O_NONBLOCK);
 #else
-        return false;
+    return false;
 #endif
 }
 
 void Bu::TcpSocket::setBlocking( bool bBlocking )
 {
-        this->bBlocking = bBlocking;
+    this->bBlocking = bBlocking;
 #ifndef WIN32
-        if( bBlocking )
-        {
-                fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) & (~O_NONBLOCK) );
-        }
-        else
-        {
-                fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) | O_NONBLOCK );
-        }
+    if( bBlocking )
+    {
+        fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) & (~O_NONBLOCK) );
+    }
+    else
+    {
+        fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) | O_NONBLOCK );
+    }
 #else
-        u_long iMode;
-        if( bBlocking )
-                iMode = 0;
-        else
-                iMode = 1;
-        //-------------------------
-        // Set the socket I/O mode: In this case FIONBIO
-        // enables or disables the blocking mode for the 
-        // socket based on the numerical value of iMode.
-        // If iMode = 0, blocking is enabled; 
-        // If iMode != 0, non-blocking mode is enabled.
-        bu_ioctlsocket(nTcpSocket, FIONBIO, &iMode);
-#endif  
+    u_long iMode;
+    if( bBlocking )
+        iMode = 0;
+    else
+        iMode = 1;
+    //-------------------------
+    // Set the socket I/O mode: In this case FIONBIO
+    // enables or disables the blocking mode for the 
+    // socket based on the numerical value of iMode.
+    // If iMode = 0, blocking is enabled; 
+    // If iMode != 0, non-blocking mode is enabled.
+    bu_ioctlsocket(nTcpSocket, FIONBIO, &iMode);
+#endif  
 }
 
 void Bu::TcpSocket::setSize( Bu::size )
@@ -430,53 +430,53 @@ void Bu::TcpSocket::flush()
 
 bool Bu::TcpSocket::isOpen()
 {
-        return bActive;
+    return bActive;
 }
 
 void Bu::TcpSocket::setAddress()
 {
-        struct sockaddr_in addr;
-        socklen_t len = sizeof(addr);
-        addr.sin_family = AF_INET;
-        bu_getpeername( nTcpSocket, (sockaddr *)(&addr), &len );
-        sAddress = bu_inet_ntoa( addr.sin_addr );
+    struct sockaddr_in addr;
+    socklen_t len = sizeof(addr);
+    addr.sin_family = AF_INET;
+    bu_getpeername( nTcpSocket, (sockaddr *)(&addr), &len );
+    sAddress = bu_inet_ntoa( addr.sin_addr );
 }
 
 Bu::String Bu::TcpSocket::getAddress() const
 {
-        return sAddress;
+    return sAddress;
 }
 
 Bu::TcpSocket::operator Bu::TcpSocket::handle() const
 {
-        return nTcpSocket;
+    return nTcpSocket;
 }
 
 Bu::TcpSocket::handle Bu::TcpSocket::getHandle() const
 {
-        return nTcpSocket;
+    return nTcpSocket;
 }
 
 Bu::TcpSocket::handle Bu::TcpSocket::takeHandle()
 {
-        handle nRet = nTcpSocket;
-        bActive = false;
-        nTcpSocket = 0;
-        return nRet;
+    handle nRet = nTcpSocket;
+    bActive = false;
+    nTcpSocket = 0;
+    return nRet;
 }
 
 Bu::size Bu::TcpSocket::getSize() const
 {
-        throw UnsupportedException();
+    throw UnsupportedException();
 }
 
 Bu::size Bu::TcpSocket::getBlockSize() const
 {
-        return 1500; //TODO: Fix this, it's stupid.
+    return 1500; //TODO: Fix this, it's stupid.
 }
 
 Bu::String Bu::TcpSocket::getLocation() const
 {
-        return getAddress();
+    return getAddress();
 }
 
diff --git a/src/stable/tcpsocket.h b/src/stable/tcpsocket.h
index 92b3c1f..16eca12 100644
--- a/src/stable/tcpsocket.h
+++ b/src/stable/tcpsocket.h
@@ -17,110 +17,110 @@
 
 namespace Bu
 {
-        subExceptionDeclBegin( TcpSocketException );
-                enum {
-                        cRead,
-                        cWrite,
-                        cBadRead,
-                        cClosed,
-                        cTimeout
-                };
-        subExceptionDeclEnd();
-
-        /**
-         * Network socket stream class.  This class provides a mechanism for
-         * communicating over a network using TCP/IP.  It will provide other low
-         * level protocol and addressing support later on, but for now it's just
-         * standard STREAM TCP/IP sockets.
-         *
-         * Unlike system sockets, these sockets are opened by default in
-         * non-blocking mode, you can specify your own timeout for opening a socket,
-         * and a number of non-fatal error messages have been automatically handled
-         * and treated as standard no-data-available-yet situations on read.
-         *
-         * Please note that there is a condition that will occur eventually (at
-         * least on *nix systems) that will trigger a SIGPIPE condition.  This
-         * will terminate your program immediately unless handled properly.  Most
-         * people doing any connections with TcpSocket will want to put this in
-         * their program somewhere before they use it:
-         *@code
-         #include <signal.h>
-         ...
-         ...
-         ...
-         sigset( SIGPIPE, SIG_IGN ); // do this before you use a Bu::TcpSocket
-         @endcode
-         * When this is done, Bu::TcpSocket will simply throw a broken pipe
-         * exception just like every other error condition, allowing your program
-         * to handle it sanely.
-         *
-         *@ingroup Serving
-         *@ingroup Streams
-         */
-        class TcpSocket : public Stream
-        {
-        public:
+    subExceptionDeclBegin( TcpSocketException );
+        enum {
+            cRead,
+            cWrite,
+            cBadRead,
+            cClosed,
+            cTimeout
+        };
+    subExceptionDeclEnd();
+
+    /**
+     * Network socket stream class.  This class provides a mechanism for
+     * communicating over a network using TCP/IP.  It will provide other low
+     * level protocol and addressing support later on, but for now it's just
+     * standard STREAM TCP/IP sockets.
+     *
+     * Unlike system sockets, these sockets are opened by default in
+     * non-blocking mode, you can specify your own timeout for opening a socket,
+     * and a number of non-fatal error messages have been automatically handled
+     * and treated as standard no-data-available-yet situations on read.
+     *
+     * Please note that there is a condition that will occur eventually (at
+     * least on *nix systems) that will trigger a SIGPIPE condition.  This
+     * will terminate your program immediately unless handled properly.  Most
+     * people doing any connections with TcpSocket will want to put this in
+     * their program somewhere before they use it:
+     *@code
+     #include <signal.h>
+     ...
+     ...
+     ...
+     sigset( SIGPIPE, SIG_IGN ); // do this before you use a Bu::TcpSocket
+     @endcode
+     * When this is done, Bu::TcpSocket will simply throw a broken pipe
+     * exception just like every other error condition, allowing your program
+     * to handle it sanely.
+     *
+     *@ingroup Serving
+     *@ingroup Streams
+     */
+    class TcpSocket : public Stream
+    {
+    public:
 #ifdef WIN32
-                typedef unsigned int handle;
+        typedef unsigned int handle;
 #else
-                typedef int handle;
+        typedef int handle;
 #endif
 
-                TcpSocket( handle nTcpSocket );
-                TcpSocket( const String &sAddr, int nPort, int nTimeout=30,
-                                bool bBlocking=true );
-                virtual ~TcpSocket();
-                
-                virtual void close();
-                virtual size read( void *pBuf, size nBytes );
-                virtual size read( void *pBuf, size nBytes,
-                                uint32_t nSec, uint32_t nUSec=0 );
-                virtual size write( const void *pBuf, size nBytes );
-                virtual size write( const void *pBuf, size nBytes,
-                                uint32_t nSec, uint32_t nUSec=0 );
-                using Stream::write;
-
-                virtual size tell();
-                virtual void seek( size offset );
-                virtual void setPos( size pos );
-                virtual void setPosEnd( size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
-
-                virtual void flush();
-
-                virtual bool canRead();
-                virtual bool canWrite();
-
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
-
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
-
-                virtual void setSize( size iSize );
-
-                Bu::String getAddress() const;
-                operator handle() const;
-
-                handle getHandle() const;
-                handle takeHandle();
-
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
-
-        private:
-                void setAddress();
-
-                handle nTcpSocket;
-                
-                bool bActive;
-                bool bBlocking;
-                String sReadBuf;
-                String sAddress;
-        };
+        TcpSocket( handle nTcpSocket );
+        TcpSocket( const String &sAddr, int nPort, int nTimeout=30,
+                bool bBlocking=true );
+        virtual ~TcpSocket();
+        
+        virtual void close();
+        virtual size read( void *pBuf, size nBytes );
+        virtual size read( void *pBuf, size nBytes,
+                uint32_t nSec, uint32_t nUSec=0 );
+        virtual size write( const void *pBuf, size nBytes );
+        virtual size write( const void *pBuf, size nBytes,
+                uint32_t nSec, uint32_t nUSec=0 );
+        using Stream::write;
+
+        virtual size tell();
+        virtual void seek( size offset );
+        virtual void setPos( size pos );
+        virtual void setPosEnd( size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
+
+        virtual void flush();
+
+        virtual bool canRead();
+        virtual bool canWrite();
+
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
+
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
+
+        virtual void setSize( size iSize );
+
+        Bu::String getAddress() const;
+        operator handle() const;
+
+        handle getHandle() const;
+        handle takeHandle();
+
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
+
+    private:
+        void setAddress();
+
+        handle nTcpSocket;
+        
+        bool bActive;
+        bool bBlocking;
+        String sReadBuf;
+        String sAddress;
+    };
 }
 
 #endif
diff --git a/src/stable/thread.cpp b/src/stable/thread.cpp
index 30443e6..ddb7ff5 100644
--- a/src/stable/thread.cpp
+++ b/src/stable/thread.cpp
@@ -10,7 +10,7 @@
 namespace Bu { subExceptionDef( ThreadException ); }
 
 Bu::ThreadId::ThreadId( pthread_t tId ) :
-        tId( tId )
+    tId( tId )
 {
 }
 
@@ -20,12 +20,12 @@ Bu::ThreadId::ThreadId()
 
 bool Bu::ThreadId::operator==( const Bu::ThreadId &rhs )
 {
-        return pthread_equal( tId, rhs.tId );
+    return pthread_equal( tId, rhs.tId );
 }
 
 bool Bu::ThreadId::operator!=( const ThreadId &rhs )
 {
-        return !pthread_equal( tId, rhs.tId );
+    return !pthread_equal( tId, rhs.tId );
 }
 
 Bu::Thread::Thread()
@@ -38,45 +38,45 @@ Bu::Thread::~Thread()
 
 Bu::ThreadId Bu::Thread::currentThread()
 {
-        return ThreadId( pthread_self() );
+    return ThreadId( pthread_self() );
 }
 
 bool Bu::Thread::start()
 {
-        if( pthread_create( &ptHandle, NULL, threadRunner, this ) )
-        {
-                throw Bu::ThreadException("Could not start thread.");
-        }
+    if( pthread_create( &ptHandle, NULL, threadRunner, this ) )
+    {
+        throw Bu::ThreadException("Could not start thread.");
+    }
 
-        return true;
+    return true;
 }
 
 bool Bu::Thread::stop()
 {
-        pthread_cancel( ptHandle );
+    pthread_cancel( ptHandle );
 
-        return true;
+    return true;
 }
 
 void *Bu::Thread::threadRunner( void *pThread )
 {
-        ((Thread *)pThread)->run();
-        pthread_exit( NULL );
-        return NULL;
+    ((Thread *)pThread)->run();
+    pthread_exit( NULL );
+    return NULL;
 }
 
 bool Bu::Thread::join()
 {
-        pthread_join( ptHandle, NULL );
-        return true;
+    pthread_join( ptHandle, NULL );
+    return true;
 }
 
 void Bu::Thread::yield()
 {
 #ifndef WIN32
-        pthread_yield();
+    pthread_yield();
 #else
-        sched_yield();
+    sched_yield();
 #endif
 }
 
diff --git a/src/stable/thread.h b/src/stable/thread.h
index ae07665..ca3ab9f 100644
--- a/src/stable/thread.h
+++ b/src/stable/thread.h
@@ -15,120 +15,120 @@
 
 namespace Bu
 {
-        subExceptionDecl( ThreadException );
-        class ThreadId
-        {
-        friend class Thread;
-        private:
-                ThreadId( pthread_t tId );
-
-        public:
-                ThreadId();
-
-                bool operator==( const ThreadId &rhs );
-                bool operator!=( const ThreadId &rhs );
-
-        private:
-                pthread_t tId;
-        };
-
-        /**
-         * Simple thread class.  This wraps the basic pthread (posix threads)
-         * system in an object oriented sort of way.  It allows you to create a
-         * class with standard member variables and callable functions that can be
-         * run in it's own thread, one per class instance.
-         *@ingroup Threading
-         */
-        class Thread
-        {
-        public:
-                /**
-                 * Construct an Thread thread.
-                 */
-                Thread();
-
-                /**
-                 * Destroy an Thread thread.
-                 */
-                virtual ~Thread();
-
-                static ThreadId currentThread();
-                ThreadId getId() { return ThreadId( ptHandle ); }
-
-                /**
-                 * Begin thread execution.  This will call the overridden run function,
-                 * which will simply execute in it's own thread until the function
-                 * exits, the thread is killed, or the thread is cancelled (optionally).
-                 * The thread started in this manner has access to all of it's class
-                 * variables, but be sure to protect possible multiple-access with
-                 * ThreadMutex objects.
-                 * @returns True if starting the thread was successful.  False if
-                 * something went wrong and the thread has not started.
-                 */
-                bool start();
-
-                /**
-                 * Forcibly kill a thread.  This is not generally considered a good
-                 * thing to do, but in those rare cases you need it, it's invaluable.
-                 * The problem with stopping (or killing) a thread is that it stops it
-                 * the moment you call stop, no matter what it's doing.  The object
-                 * oriented approach to this will help clean up any class variables
-                 * that were used, but anything not managed as a member variable will
-                 * probably create a memory leak type of situation.  Instead of stop,
-                 * consider using cancel, which can be handled by the running thread in
-                 * a graceful manner.
-                 *@returns True if the thread was stopped, false otherwise.  When this
-                 * function returns the thread may not have stopped, to ensure that the
-                 * thread has really stopped, call join.
-                 */
-                bool stop();
-
-                /**
-                 * Join the thread in action.  This function performs what is commonly
-                 * called a thread join.  That is that it effectively makes the calling
-                 * thread an the Thread thread contained in the called object one in the
-                 * same, and pauses the calling thread until the called thread exits.
-                 * That is, when called from, say, your main(), mythread.join() will
-                 * not return until the thread mythread has exited.  This is very handy
-                 * at the end of programs to ensure all of your data was cleaned up.
-                 *@returns True if the thread was joined, false if the thread couldn't
-                 * be joined, usually because it isn't running to begin with.
-                 */
-                bool join();
-
-        private:
-                pthread_t ptHandle;     /**< Internal handle to the posix thread. */
-
-        protected:
-                /**
-                 * The workhorse of the Thread class.  This is the function that will
-                 * run in the thread, when this function exits the thread dies and is
-                 * cleaned up by the system.  Make sure to read up on Bu::Mutex,
-                 * Bu::Condition, and the Bu::Synchro* classes to see how to control
-                 * and protect everything you do in a safe way within this function.
-                 *@returns I'm not sure right now, but this is the posix standard form.
-                 */
-                virtual void run()=0;
-
-                /**
-                 * Gives up some cpu-time in the currently running thread.  If a thread
-                 * is working hard, but you want to give other threads on the system
-                 * some time to do some work, call yield.
-                 */
-                void yield();
-
-        private:
-                /**
-                 * This is the hidden-heart of the thread system.  While run is what the
-                 * user gets to override, and everything said about it is true, this is
-                 * the function that actually makes up the thread, it simply calls the
-                 * run member function in an OO-friendly way.  This is what allows us to
-                 * use member variables from within the thread itself.
-                 *@param pThread Should always be this.
-                 *@returns This is specified by posix, I'm not sure yet.
-                 */
-                static void *threadRunner( void *pThread );
-        };
+    subExceptionDecl( ThreadException );
+    class ThreadId
+    {
+    friend class Thread;
+    private:
+        ThreadId( pthread_t tId );
+
+    public:
+        ThreadId();
+
+        bool operator==( const ThreadId &rhs );
+        bool operator!=( const ThreadId &rhs );
+
+    private:
+        pthread_t tId;
+    };
+
+    /**
+     * Simple thread class.  This wraps the basic pthread (posix threads)
+     * system in an object oriented sort of way.  It allows you to create a
+     * class with standard member variables and callable functions that can be
+     * run in it's own thread, one per class instance.
+     *@ingroup Threading
+     */
+    class Thread
+    {
+    public:
+        /**
+         * Construct an Thread thread.
+         */
+        Thread();
+
+        /**
+         * Destroy an Thread thread.
+         */
+        virtual ~Thread();
+
+        static ThreadId currentThread();
+        ThreadId getId() { return ThreadId( ptHandle ); }
+
+        /**
+         * Begin thread execution.  This will call the overridden run function,
+         * which will simply execute in it's own thread until the function
+         * exits, the thread is killed, or the thread is cancelled (optionally).
+         * The thread started in this manner has access to all of it's class
+         * variables, but be sure to protect possible multiple-access with
+         * ThreadMutex objects.
+         * @returns True if starting the thread was successful.  False if
+         * something went wrong and the thread has not started.
+         */
+        bool start();
+
+        /**
+         * Forcibly kill a thread.  This is not generally considered a good
+         * thing to do, but in those rare cases you need it, it's invaluable.
+         * The problem with stopping (or killing) a thread is that it stops it
+         * the moment you call stop, no matter what it's doing.  The object
+         * oriented approach to this will help clean up any class variables
+         * that were used, but anything not managed as a member variable will
+         * probably create a memory leak type of situation.  Instead of stop,
+         * consider using cancel, which can be handled by the running thread in
+         * a graceful manner.
+         *@returns True if the thread was stopped, false otherwise.  When this
+         * function returns the thread may not have stopped, to ensure that the
+         * thread has really stopped, call join.
+         */
+        bool stop();
+
+        /**
+         * Join the thread in action.  This function performs what is commonly
+         * called a thread join.  That is that it effectively makes the calling
+         * thread an the Thread thread contained in the called object one in the
+         * same, and pauses the calling thread until the called thread exits.
+         * That is, when called from, say, your main(), mythread.join() will
+         * not return until the thread mythread has exited.  This is very handy
+         * at the end of programs to ensure all of your data was cleaned up.
+         *@returns True if the thread was joined, false if the thread couldn't
+         * be joined, usually because it isn't running to begin with.
+         */
+        bool join();
+
+    private:
+        pthread_t ptHandle; /**< Internal handle to the posix thread. */
+
+    protected:
+        /**
+         * The workhorse of the Thread class.  This is the function that will
+         * run in the thread, when this function exits the thread dies and is
+         * cleaned up by the system.  Make sure to read up on Bu::Mutex,
+         * Bu::Condition, and the Bu::Synchro* classes to see how to control
+         * and protect everything you do in a safe way within this function.
+         *@returns I'm not sure right now, but this is the posix standard form.
+         */
+        virtual void run()=0;
+
+        /**
+         * Gives up some cpu-time in the currently running thread.  If a thread
+         * is working hard, but you want to give other threads on the system
+         * some time to do some work, call yield.
+         */
+        void yield();
+
+    private:
+        /**
+         * This is the hidden-heart of the thread system.  While run is what the
+         * user gets to override, and everything said about it is true, this is
+         * the function that actually makes up the thread, it simply calls the
+         * run member function in an OO-friendly way.  This is what allows us to
+         * use member variables from within the thread itself.
+         *@param pThread Should always be this.
+         *@returns This is specified by posix, I'm not sure yet.
+         */
+        static void *threadRunner( void *pThread );
+    };
 }
 
 #endif
diff --git a/src/stable/trace.cpp b/src/stable/trace.cpp
index c072fd9..2b3b863 100644
--- a/src/stable/trace.cpp
+++ b/src/stable/trace.cpp
@@ -9,59 +9,59 @@
 
 void Bu::__tracer( const char *pf )
 {
-        printf("trace: %s\n", pf );
+    printf("trace: %s\n", pf );
 }
 
 template<> void Bu::__tracer_format<float>( const float &v )
 {
-        printf("%f", v );
+    printf("%f", v );
 }
 
 template<> void Bu::__tracer_format<double>( const double &v )
 {
-        printf("%f", v );
+    printf("%f", v );
 }
 
 template<> void Bu::__tracer_format<void *>( void * const &v )
 {
-        printf("0x%08X", (ptrdiff_t)v );
+    printf("0x%08X", (ptrdiff_t)v );
 }
 
 template<> void Bu::__tracer_format<char *>( char * const &v )
 {
-        printf("\"%s\"", v );
+    printf("\"%s\"", v );
 }
 
 template<> void Bu::__tracer_format<char **>( char ** const &v )
 {
-        printf("[");
-        for( int j = 0; v[j]; j++ )
-        {
-                if( j > 0 )
-                        printf(", ");
-                printf("\"%s\"", v[j] );
-        }
-        printf("]");
+    printf("[");
+    for( int j = 0; v[j]; j++ )
+    {
+        if( j > 0 )
+            printf(", ");
+        printf("\"%s\"", v[j] );
+    }
+    printf("]");
 }
 
 template<> void Bu::__tracer_format<void const *>( void const * const &v )
 {
-        printf("0x%08X", (ptrdiff_t)v );
+    printf("0x%08X", (ptrdiff_t)v );
 }
 
 template<> void Bu::__tracer_format<char const *>( char const * const &v )
 {
-        printf("\"%s\"", v );
+    printf("\"%s\"", v );
 }
 
 template<> void Bu::__tracer_format<char const **>( char const ** const &v )
 {
-        printf("[");
-        for( int j = 0; v[j]; j++ )
-        {
-                if( j > 0 )
-                        printf(", ");
-                printf("\"%s\"", v[j] );
-        }
-        printf("]");
+    printf("[");
+    for( int j = 0; v[j]; j++ )
+    {
+        if( j > 0 )
+            printf(", ");
+        printf("\"%s\"", v[j] );
+    }
+    printf("]");
 }
diff --git a/src/stable/trace.h b/src/stable/trace.h
index da67f03..d47df9c 100644
--- a/src/stable/trace.h
+++ b/src/stable/trace.h
@@ -17,165 +17,165 @@
 
 namespace Bu
 {
-/*      template<typename t> void __tracer_format( t &v )
-        {
-                __tracer_format( *const_cast<const t *>(&v) );
-        }
+/*  template<typename t> void __tracer_format( t &v )
+    {
+        __tracer_format( *const_cast<const t *>(&v) );
+    }
 */
-        template<typename t> void __tracer_format( const t &v )
-        {
-                Bu::sio << v;
-        }
+    template<typename t> void __tracer_format( const t &v )
+    {
+        Bu::sio << v;
+    }
 
-        void __tracer( const char *pf );
+    void __tracer( const char *pf );
 
-        #define looper( vv )                                                            \
-                for( ; *n; n++ )                                                                \
-                {                                                                                               \
-                        if( bInBracket == true )                                        \
-                        {                                                                                       \
-                                if( *n == '>' )                                                 \
-                                        bInBracket = false;                                     \
-                        }                                                                                       \
-                        else if( *n == ',' || *n == ')' )                       \
-                        {                                                                                       \
-                                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, 1, stdout );      \
-                                fwrite("=", 1, 1, stdout);                              \
-                                __tracer_format( vv );                                  \
-                                s = n;                                                                  \
-                                n++;                                                                    \
-                                break;                                                                  \
-                        }                                                                                       \
-                        else if( *n == '<' )                                            \
-                        {                                                                                       \
-                                bInBracket = true;                                              \
-                        }                                                                                       \
-                } (void)0
-        
-        template<typename t1> void __tracer( const char *pf, t1 &v1 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2> void __tracer( const char *pf,
-                t1 &v1, t2 &v2 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2, typename t3>
-        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                looper( v3 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2, typename t3, typename t4>
-        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                looper( v3 );
-                looper( v4 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2, typename t3, typename t4, typename t5>
-        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                looper( v3 );
-                looper( v4 );
-                looper( v5 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2, typename t3, typename t4, typename t5,
-        typename t6>
-        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5,
-                t6 &v6)
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                looper( v3 );
-                looper( v4 );
-                looper( v5 );
-                looper( v6 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
-        
-        template<typename t1, typename t2, typename t3, typename t4, typename t5,
-        typename t6, typename t7>
-        void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5,
-                t6 &v6, t7 &v7 )
-        {
-                printf("trace: ");
-                const char *s = pf;
-                const char *n = pf;
-                bool bInBracket = false;
-                looper( v1 );
-                looper( v2 );
-                looper( v3 );
-                looper( v4 );
-                looper( v5 );
-                looper( v6 );
-                looper( v7 );
-                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
-                fwrite( "\n", 1, 1, stdout );
-                fflush( stdout );
-        }
+    #define looper( vv )                                \
+        for( ; *n; n++ )                                \
+        {                                               \
+            if( bInBracket == true )                    \
+            {                                           \
+                if( *n == '>' )                         \
+                    bInBracket = false;                 \
+            }                                           \
+            else if( *n == ',' || *n == ')' )           \
+            {                                           \
+                fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, 1, stdout );  \
+                fwrite("=", 1, 1, stdout);              \
+                __tracer_format( vv );                  \
+                s = n;                                  \
+                n++;                                    \
+                break;                                  \
+            }                                           \
+            else if( *n == '<' )                        \
+            {                                           \
+                bInBracket = true;                      \
+            }                                           \
+        } (void)0
+    
+    template<typename t1> void __tracer( const char *pf, t1 &v1 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2> void __tracer( const char *pf,
+        t1 &v1, t2 &v2 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2, typename t3>
+    void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        looper( v3 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2, typename t3, typename t4>
+    void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        looper( v3 );
+        looper( v4 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2, typename t3, typename t4, typename t5>
+    void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        looper( v3 );
+        looper( v4 );
+        looper( v5 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2, typename t3, typename t4, typename t5,
+    typename t6>
+    void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5,
+        t6 &v6)
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        looper( v3 );
+        looper( v4 );
+        looper( v5 );
+        looper( v6 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
+    
+    template<typename t1, typename t2, typename t3, typename t4, typename t5,
+    typename t6, typename t7>
+    void __tracer( const char *pf, t1 &v1, t2 &v2, t3 &v3, t4 &v4, t5 &v5,
+        t6 &v6, t7 &v7 )
+    {
+        printf("trace: ");
+        const char *s = pf;
+        const char *n = pf;
+        bool bInBracket = false;
+        looper( v1 );
+        looper( v2 );
+        looper( v3 );
+        looper( v4 );
+        looper( v5 );
+        looper( v6 );
+        looper( v7 );
+        fwrite( s, (ptrdiff_t)n-(ptrdiff_t)s, strlen(s), stdout );
+        fwrite( "\n", 1, 1, stdout );
+        fflush( stdout );
+    }
 #undef looper
-        
-        template<> void __tracer_format<float>( const float &v );
-        template<> void __tracer_format<double>( const double &v );
-        template<> void __tracer_format<void *>( void * const &v );
-        template<> void __tracer_format<char *>( char * const &v );
-        template<> void __tracer_format<char **>( char ** const &v );
-        template<> void __tracer_format<void const *>( void const * const &v );
-        template<> void __tracer_format<char const *>( char const * const &v );
-        template<> void __tracer_format<char const **>( char const ** const &v );
+    
+    template<> void __tracer_format<float>( const float &v );
+    template<> void __tracer_format<double>( const double &v );
+    template<> void __tracer_format<void *>( void * const &v );
+    template<> void __tracer_format<char *>( char * const &v );
+    template<> void __tracer_format<char **>( char ** const &v );
+    template<> void __tracer_format<void const *>( void const * const &v );
+    template<> void __tracer_format<char const *>( char const * const &v );
+    template<> void __tracer_format<char const **>( char const ** const &v );
 }
 
 #ifdef BU_TRACE
diff --git a/src/stable/unitsuite.cpp b/src/stable/unitsuite.cpp
index b6057d0..e0606e6 100644
--- a/src/stable/unitsuite.cpp
+++ b/src/stable/unitsuite.cpp
@@ -17,14 +17,14 @@ using namespace Bu;
 #include <unistd.h>
 
 Bu::UnitSuite::UnitSuite() :
-        iOptions( 0 ),
-        iNameWidth( 0 )
+    iOptions( 0 ),
+    iNameWidth( 0 )
 {
 }
 
 Bu::UnitSuite::UnitSuite( int iOptions ) :
-        iOptions( iOptions ),
-        iNameWidth( 0 )
+    iOptions( iOptions ),
+    iNameWidth( 0 )
 {
 }
 
@@ -34,240 +34,240 @@ Bu::UnitSuite::~UnitSuite()
 
 int Bu::UnitSuite::run( int argc, char *argv[] )
 {
-        bool bCleanup = true;
-        OptParser p;
-        p.addOption( Bu::slot( this, &Bu::UnitSuite::onListCases ), 'l', "list",
-                        "List available test cases." );
-        p.addOption( bCleanup, "no-cleanup", "Don't erase temp files.");
-        p.setOverride( "no-cleanup", false );
-        p.setNonOption( Bu::slot( this, &Bu::UnitSuite::onAddTest ) );
-        p.addHelpOption();
-        p.parse( argc, argv );
-
-        if( !hSelTests.isEmpty() )
-        {
-                TestList lSub;
-                for( TestList::iterator i = lTests.begin(); i != lTests.end(); i++ )
-                {
-                        if( hSelTests.has( (*i).sName ) )
-                                lSub.append( *i );
-                }
-
-                lTests = lSub;
-        }
-
-        int iEPass = 0;
-        int iEFail = 0;
-        int iUPass = 0;
-        int iUFail = 0;
-        for( TestList::iterator i = lTests.begin(); i != lTests.end(); i++ )
-        {
-                sio << Fmt( iNameWidth+3, Fmt::Left ).fill('.') << i->sName
-                        << sio.flush;
-                try
-                {
-                        iStepCount = -1;
-                        iProgress = 0;
-                        (this->*(i->fTest))();
-                        switch( i->eExpect )
-                        {
-                                case expectPass:
-                                        sio << "pass." << sio.nl;
-                                        iEPass++;
-                                        break;
-
-                                case expectFail:
-                                        sio << "unexpected pass." << sio.nl;
-                                        iUPass++;
-                                        break;
-                        }
-                }
-                catch( Failed &e )
-                {
-                        switch( i->eExpect )
-                        {
-                                case expectPass:
-                                        sio << "unexpected ";
-                                        iUFail++;
-                                        break;
-
-                                case expectFail:
-                                        sio << "expected ";
-                                        iEFail++;
-                                        break;
-                        }
-                        if( e.bFile )
-                        {
-                                sio << "fail in unitTest(" << e.str << "). (" << e.sFile
-                                        << ":" << e.nLine << ")." << sio.nl;
-                        }
-                        else
-                        {
-                                sio << "fail in unitTest(" << e.str << ")." << sio.nl;
-                        }
-
-                        if( (iOptions & optStopOnError) )
-                                return 0;
-                }
-                catch( std::exception &e )
-                {
-                        switch( i->eExpect )
-                        {
-                                case expectPass:
-                                        sio << "unexpected ";
-                                        iUFail++;
-                                        break;
-
-                                case expectFail:
-                                        sio << "expected ";
-                                        iEFail++;
-                                        break;
-                        }
-                        sio << "fail with unknown exception.  what: " << e.what() << sio.nl;
-
-                        if( (iOptions & optStopOnError) )
-                                return 0;
-                }
-                catch( ... )
-                {
-                        switch( i->eExpect )
-                        {
-                                case expectPass:
-                                        sio << "unexpected ";
-                                        iUFail++;
-                                        break;
-
-                                case expectFail:
-                                        sio << "expected ";
-                                        iEFail++;
-                                        break;
-                        }
-                        sio << "fail with external exception." << sio.nl;
-
-                        if( (iOptions & optStopOnError) )
-                                return 0;
-                }
-        }
-
-        sio << sio.nl
-                << "Report:" << sio.nl
-                << "\tTotal tests run:     " << lTests.getSize() << sio.nl
-                << "\tExpected passes:     " << iEPass << sio.nl
-                << "\tExpected failures:   " << iEFail << sio.nl
-                << "\tUnexpected passes:   " << iUPass << sio.nl
-                << "\tUnexpected failures: " << iUFail << sio.nl << sio.nl;
-        if( iUPass == 0 && iUFail == 0 )
-                sio << "\tNothing unexpected." << sio.nl << sio.nl;
-
-        if( bCleanup )
-        {
-                for( StrList::iterator i = lFileCleanup.begin(); i; i++ )
-                {
-                        unlink( (*i).getStr() );
-                }
-        }
-
-        return 0;
+    bool bCleanup = true;
+    OptParser p;
+    p.addOption( Bu::slot( this, &Bu::UnitSuite::onListCases ), 'l', "list",
+            "List available test cases." );
+    p.addOption( bCleanup, "no-cleanup", "Don't erase temp files.");
+    p.setOverride( "no-cleanup", false );
+    p.setNonOption( Bu::slot( this, &Bu::UnitSuite::onAddTest ) );
+    p.addHelpOption();
+    p.parse( argc, argv );
+
+    if( !hSelTests.isEmpty() )
+    {
+        TestList lSub;
+        for( TestList::iterator i = lTests.begin(); i != lTests.end(); i++ )
+        {
+            if( hSelTests.has( (*i).sName ) )
+                lSub.append( *i );
+        }
+
+        lTests = lSub;
+    }
+
+    int iEPass = 0;
+    int iEFail = 0;
+    int iUPass = 0;
+    int iUFail = 0;
+    for( TestList::iterator i = lTests.begin(); i != lTests.end(); i++ )
+    {
+        sio << Fmt( iNameWidth+3, Fmt::Left ).fill('.') << i->sName
+            << sio.flush;
+        try
+        {
+            iStepCount = -1;
+            iProgress = 0;
+            (this->*(i->fTest))();
+            switch( i->eExpect )
+            {
+                case expectPass:
+                    sio << "pass." << sio.nl;
+                    iEPass++;
+                    break;
+
+                case expectFail:
+                    sio << "unexpected pass." << sio.nl;
+                    iUPass++;
+                    break;
+            }
+        }
+        catch( Failed &e )
+        {
+            switch( i->eExpect )
+            {
+                case expectPass:
+                    sio << "unexpected ";
+                    iUFail++;
+                    break;
+
+                case expectFail:
+                    sio << "expected ";
+                    iEFail++;
+                    break;
+            }
+            if( e.bFile )
+            {
+                sio << "fail in unitTest(" << e.str << "). (" << e.sFile
+                    << ":" << e.nLine << ")." << sio.nl;
+            }
+            else
+            {
+                sio << "fail in unitTest(" << e.str << ")." << sio.nl;
+            }
+
+            if( (iOptions & optStopOnError) )
+                return 0;
+        }
+        catch( std::exception &e )
+        {
+            switch( i->eExpect )
+            {
+                case expectPass:
+                    sio << "unexpected ";
+                    iUFail++;
+                    break;
+
+                case expectFail:
+                    sio << "expected ";
+                    iEFail++;
+                    break;
+            }
+            sio << "fail with unknown exception.  what: " << e.what() << sio.nl;
+
+            if( (iOptions & optStopOnError) )
+                return 0;
+        }
+        catch( ... )
+        {
+            switch( i->eExpect )
+            {
+                case expectPass:
+                    sio << "unexpected ";
+                    iUFail++;
+                    break;
+
+                case expectFail:
+                    sio << "expected ";
+                    iEFail++;
+                    break;
+            }
+            sio << "fail with external exception." << sio.nl;
+
+            if( (iOptions & optStopOnError) )
+                return 0;
+        }
+    }
+
+    sio << sio.nl
+        << "Report:" << sio.nl
+        << "\tTotal tests run:     " << lTests.getSize() << sio.nl
+        << "\tExpected passes:     " << iEPass << sio.nl
+        << "\tExpected failures:   " << iEFail << sio.nl
+        << "\tUnexpected passes:   " << iUPass << sio.nl
+        << "\tUnexpected failures: " << iUFail << sio.nl << sio.nl;
+    if( iUPass == 0 && iUFail == 0 )
+        sio << "\tNothing unexpected." << sio.nl << sio.nl;
+
+    if( bCleanup )
+    {
+        for( StrList::iterator i = lFileCleanup.begin(); i; i++ )
+        {
+            unlink( (*i).getStr() );
+        }
+    }
+
+    return 0;
 }
 
 Bu::File Bu::UnitSuite::tempFile( Bu::String &sFileName )
 {
-        Bu::File f = Bu::File::tempFile( sFileName );
-        lFileCleanup.append( sFileName );
-        return f;
+    Bu::File f = Bu::File::tempFile( sFileName );
+    lFileCleanup.append( sFileName );
+    return f;
 }
 
 void Bu::UnitSuite::add( Test fTest, const Bu::String &sName, Expect e )
 {
-        TestInfo ti;
-        ti.sName = sName;
-        ti.eExpect = e;
-        long index = ti.sName.rfindIdx("::");
-        if( index != -1 )
-        {
-                String tmp = sSuiteName;
-                tmp += ti.sName.getStr()+index;
-                ti.sName = tmp;
-        }
-        ti.fTest = fTest;
-        lTests.append( ti );
-        if( iNameWidth < ti.sName.getSize() )
-                iNameWidth = ti.sName.getSize();
+    TestInfo ti;
+    ti.sName = sName;
+    ti.eExpect = e;
+    long index = ti.sName.rfindIdx("::");
+    if( index != -1 )
+    {
+        String tmp = sSuiteName;
+        tmp += ti.sName.getStr()+index;
+        ti.sName = tmp;
+    }
+    ti.fTest = fTest;
+    lTests.append( ti );
+    if( iNameWidth < ti.sName.getSize() )
+        iNameWidth = ti.sName.getSize();
 }
 
 void Bu::UnitSuite::setName( const String &sName )
 {
-        sSuiteName = sName;
+    sSuiteName = sName;
 }
 
 void Bu::UnitSuite::dispProgress()
 {
-        if( tLastUpdate == time( NULL ) )
-                return;
-        sio << Fmt(3) << (iProgress*100/iStepCount) << "%" << "\b\b\b\b"
-                << sio.flush;
-        tLastUpdate = time( NULL );
+    if( tLastUpdate == time( NULL ) )
+        return;
+    sio << Fmt(3) << (iProgress*100/iStepCount) << "%" << "\b\b\b\b"
+        << sio.flush;
+    tLastUpdate = time( NULL );
 }
 
 void Bu::UnitSuite::setStepCount( int iSteps )
 {
-        iStepCount = iSteps;
-        if( iStepCount < 0 )
-                return;
-        tLastUpdate = 0;
-        dispProgress();
+    iStepCount = iSteps;
+    if( iStepCount < 0 )
+        return;
+    tLastUpdate = 0;
+    dispProgress();
 }
 
 void Bu::UnitSuite::incProgress( int iAmnt )
 {
-        iProgress += iAmnt;
-        if( iProgress < 0 )
-                iProgress = 0;
-        if( iProgress > iStepCount )
-                iProgress = iStepCount;
-        dispProgress();
+    iProgress += iAmnt;
+    if( iProgress < 0 )
+        iProgress = 0;
+    if( iProgress > iStepCount )
+        iProgress = iStepCount;
+    dispProgress();
 }
 
 void Bu::UnitSuite::setProgress( int iAmnt )
 {
-        iProgress = iAmnt;
-        if( iProgress < 0 )
-                iProgress = 0;
-        if( iProgress > iStepCount )
-                iProgress = iStepCount;
-        dispProgress();
+    iProgress = iAmnt;
+    if( iProgress < 0 )
+        iProgress = 0;
+    if( iProgress > iStepCount )
+        iProgress = iStepCount;
+    dispProgress();
 }
 
 int Bu::UnitSuite::onListCases( StrArray )
 {
-        sio << "Test cases:" << sio.nl;
-        for( TestList::iterator i = lTests.begin(); i; i++ )
-        {
-                sio << "\t- " << Fmt( iNameWidth, 10, Fmt::Left ) << (*i).sName << "  "
-                        << (*i).eExpect << sio.nl;
-        }
-        sio << sio.nl;
-        exit( 0 );
-        return 0;
+    sio << "Test cases:" << sio.nl;
+    for( TestList::iterator i = lTests.begin(); i; i++ )
+    {
+        sio << "\t- " << Fmt( iNameWidth, 10, Fmt::Left ) << (*i).sName << "  "
+            << (*i).eExpect << sio.nl;
+    }
+    sio << sio.nl;
+    exit( 0 );
+    return 0;
 }
 
 int Bu::UnitSuite::onAddTest( StrArray aParam )
 {
-        hSelTests.insert( aParam[0], true );
-        return 0;
+    hSelTests.insert( aParam[0], true );
+    return 0;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::UnitSuite::Expect &e )
 {
-        switch( e )
-        {
-                case Bu::UnitSuite::expectPass:
-                        return f << "expect pass";
+    switch( e )
+    {
+        case Bu::UnitSuite::expectPass:
+            return f << "expect pass";
 
-                case Bu::UnitSuite::expectFail:
-                        return f << "expect fail";
-        }
+        case Bu::UnitSuite::expectFail:
+            return f << "expect fail";
+    }
 
-        return f << "**error**";
+    return f << "**error**";
 }
 
diff --git a/src/stable/unitsuite.h b/src/stable/unitsuite.h
index 3442753..46a0773 100644
--- a/src/stable/unitsuite.h
+++ b/src/stable/unitsuite.h
@@ -17,126 +17,126 @@
 
 namespace Bu
 {
-        /**
-         * Provides a unit testing framework.  This is pretty easy to use, probably
-         * the best way to get started is to use ch to generate a template, or use
-         * the code below with appropriate tweaks:
-         *@code
-         * #include "unitsuite.h"
-         * 
-         * class Unit : public Bu::UnitSuite
-         * {
-         * public:
-         *      Unit()
-         *      {
-         *              setName("Example");
-         *              addTest( Unit::test );
-         *      }
-         * 
-         *      virtual ~Unit() { }
-         * 
-         *      //
-         *      // Tests go here
-         *      //
-         *      void test()
-         *      {
-         *              unitTest( 1 == 1 );
-         *      }
-         * };
-         * 
-         * int main( int argc, char *argv[] )
-         * {
-         *      return Unit().run( argc, argv );
-         * }
-         *
-         @endcode
-         * The main function can contain other things, but using this one exactly
-         * makes all of the test suites work exactly the same.  Using the optional
-         * setName at the top of the constructor replaces the class name with the
-         * chosen name when printing out stats and info.
-         */
-        class UnitSuite
-        {
-        public:
-                UnitSuite();
-                UnitSuite( int iOptions );
-                virtual ~UnitSuite();
-
-                int run( int argc=0, char *argv[]=NULL );
-
-                Bu::File tempFile( Bu::String &sFileName );
-
-                typedef void (UnitSuite::*Test)();
-
-                class Failed
-                {
-                public:
-                        Failed() : str(""), bFile( false ) { }
-                        Failed( const String &s ) : str( s ), bFile( false ) { }
-                        Failed( const String &s, const String &sFile, int nLine ) :
-                                str( s ), sFile( sFile ), nLine( nLine ), bFile( true ) { }
-
-                        String str;
-                        String sFile;
-                        int nLine;
-                        bool bFile;
-                };
-
-                enum
-                {
-                        optStopOnError          = 0x000001
-                };
-
-                enum Expect
-                {
-                        expectPass,
-                        expectFail
-                };
-                
-        protected:
-                void add( Test fTest, const Bu::String &sName, Expect e=expectPass );
-                void setName( const String &sName );
-
-                void dispProgress();
-                void setStepCount( int iSteps );
-                void incProgress( int iAmnt = 1 );
-                void setProgress( int iAmnt );
-
-        private:
-                int onListCases( Bu::Array<Bu::String> aParam );
-                int onAddTest( Bu::Array<Bu::String> aParam );
-
-        private:
-                typedef struct TestInfo
-                {
-                        String sName;
-                        Test fTest;
-                        Expect eExpect;
-                } TestInfo;
-
-                typedef Bu::List<TestInfo> TestList;
-                TestList lTests;
-                String sSuiteName;
-
-                int iOptions;
-
-                typedef Bu::List<Bu::String> StrList;
-                StrList lFileCleanup;
-                int iNameWidth;
-                int iStepCount;
-                int iProgress;
-                time_t tLastUpdate;
-
-                Bu::Hash<Bu::String, bool> hSelTests;
-        };
+    /**
+     * Provides a unit testing framework.  This is pretty easy to use, probably
+     * the best way to get started is to use ch to generate a template, or use
+     * the code below with appropriate tweaks:
+     *@code
+     * #include "unitsuite.h"
+     * 
+     * class Unit : public Bu::UnitSuite
+     * {
+     * public:
+     *  Unit()
+     *  {
+     *      setName("Example");
+     *      addTest( Unit::test );
+     *  }
+     * 
+     *  virtual ~Unit() { }
+     * 
+     *  //
+     *  // Tests go here
+     *  //
+     *  void test()
+     *  {
+     *      unitTest( 1 == 1 );
+     *  }
+     * };
+     * 
+     * int main( int argc, char *argv[] )
+     * {
+     *  return Unit().run( argc, argv );
+     * }
+     *
+     @endcode
+     * The main function can contain other things, but using this one exactly
+     * makes all of the test suites work exactly the same.  Using the optional
+     * setName at the top of the constructor replaces the class name with the
+     * chosen name when printing out stats and info.
+     */
+    class UnitSuite
+    {
+    public:
+        UnitSuite();
+        UnitSuite( int iOptions );
+        virtual ~UnitSuite();
+
+        int run( int argc=0, char *argv[]=NULL );
+
+        Bu::File tempFile( Bu::String &sFileName );
+
+        typedef void (UnitSuite::*Test)();
+
+        class Failed
+        {
+        public:
+            Failed() : str(""), bFile( false ) { }
+            Failed( const String &s ) : str( s ), bFile( false ) { }
+            Failed( const String &s, const String &sFile, int nLine ) :
+                str( s ), sFile( sFile ), nLine( nLine ), bFile( true ) { }
+
+            String str;
+            String sFile;
+            int nLine;
+            bool bFile;
+        };
+
+        enum
+        {
+            optStopOnError      = 0x000001
+        };
+
+        enum Expect
+        {
+            expectPass,
+            expectFail
+        };
+        
+    protected:
+        void add( Test fTest, const Bu::String &sName, Expect e=expectPass );
+        void setName( const String &sName );
+
+        void dispProgress();
+        void setStepCount( int iSteps );
+        void incProgress( int iAmnt = 1 );
+        void setProgress( int iAmnt );
+
+    private:
+        int onListCases( Bu::Array<Bu::String> aParam );
+        int onAddTest( Bu::Array<Bu::String> aParam );
+
+    private:
+        typedef struct TestInfo
+        {
+            String sName;
+            Test fTest;
+            Expect eExpect;
+        } TestInfo;
+
+        typedef Bu::List<TestInfo> TestList;
+        TestList lTests;
+        String sSuiteName;
+
+        int iOptions;
+
+        typedef Bu::List<Bu::String> StrList;
+        StrList lFileCleanup;
+        int iNameWidth;
+        int iStepCount;
+        int iProgress;
+        time_t tLastUpdate;
+
+        Bu::Hash<Bu::String, bool> hSelTests;
+    };
 
 Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::UnitSuite::Expect &e );
 }
 
 #define addTest( fn ) add( static_cast<Bu::UnitSuite::Test>(&fn), #fn )
-#define unitTest( tst ) if( !(tst) )                                                    \
-{                                                                                                                               \
-        throw Bu::UnitSuite::Failed( #tst, __FILE__, __LINE__ );        \
+#define unitTest( tst ) if( !(tst) )                            \
+{                                                               \
+    throw Bu::UnitSuite::Failed( #tst, __FILE__, __LINE__ );    \
 } else (void)0
 #define unitFailed( msg ) throw Bu::UnitSuite::Failed(msg, __FILE__, __LINE__)
 
diff --git a/src/stable/util.cpp b/src/stable/util.cpp
index b42e040..ff9901b 100644
--- a/src/stable/util.cpp
+++ b/src/stable/util.cpp
@@ -9,57 +9,57 @@
 
 int Bu::getDaysInMonth( int iMonth, int iYear )
 {
-        if( iMonth > 11 )
-        {
-                iYear += iMonth/12;
-                iMonth = iMonth%12;
-        }
-        switch( iMonth )
-        {
-        case 0:
-        case 2:
-        case 4:
-        case 6:
-        case 7:
-        case 9:
-        case 11:
-                return 31;
-                break;
+    if( iMonth > 11 )
+    {
+        iYear += iMonth/12;
+        iMonth = iMonth%12;
+    }
+    switch( iMonth )
+    {
+    case 0:
+    case 2:
+    case 4:
+    case 6:
+    case 7:
+    case 9:
+    case 11:
+        return 31;
+        break;
 
-        case 3:
-        case 5:
-        case 8:
-        case 10:
-                return 30;
-                break;
+    case 3:
+    case 5:
+    case 8:
+    case 10:
+        return 30;
+        break;
 
-        case 1:
-                if( iYear%400 == 0 )
-                        return 29;
-                if( iYear%100 == 0 )
-                        return 28;
-                if( iYear%4 == 0 )
-                        return 29;
-                return 28;
-                break;
+    case 1:
+        if( iYear%400 == 0 )
+            return 29;
+        if( iYear%100 == 0 )
+            return 28;
+        if( iYear%4 == 0 )
+            return 29;
+        return 28;
+        break;
 
-        default:
-                return -1;
-        }
+    default:
+        return -1;
+    }
 }
 void Bu::memcpy( void *pDest, const void *pSrc, size_t iBytes )
 {
 #ifdef VALTEST
-        const char *src = (const char *)pSrc;
-        char *dest = (char *)pDest;
-        for( int j = 0; j < count; j++ )
-        {
-                *dest = *src;
-                dest++;
-                src++;
-        }
+    const char *src = (const char *)pSrc;
+    char *dest = (char *)pDest;
+    for( int j = 0; j < count; j++ )
+    {
+        *dest = *src;
+        dest++;
+        src++;
+    }
 #else
-        ::memcpy( pDest, pSrc, iBytes );
+    ::memcpy( pDest, pSrc, iBytes );
 #endif
 }
 
diff --git a/src/stable/util.h b/src/stable/util.h
index 4514281..ab9cd08 100644
--- a/src/stable/util.h
+++ b/src/stable/util.h
@@ -25,158 +25,158 @@
 
 namespace Bu
 {
-        /**
-         * Swap the value of two variables, uses references, so it's pretty safe.
-         * Objects passed in must support a basic assignemnt operator (=);
-         *@param a Variable to recieve the value of parameter b
-         *@param b Variable to recieve the value of parameter a
-         */
-        template<typename item>
-        void swap( item &a, item &b )
-        {
-                item tmp = a;
-                a = b;
-                b = tmp;
-        }
+    /**
+     * Swap the value of two variables, uses references, so it's pretty safe.
+     * Objects passed in must support a basic assignemnt operator (=);
+     *@param a Variable to recieve the value of parameter b
+     *@param b Variable to recieve the value of parameter a
+     */
+    template<typename item>
+    void swap( item &a, item &b )
+    {
+        item tmp = a;
+        a = b;
+        b = tmp;
+    }
 
-        /**
-         * Finds the lesser of the two objects, objects passed in must be
-         * less-than-comparable.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@returns A reference to the lesser of a or b.
-         */
-        template<typename item>
-        const item &buMin( const item &a, const item &b )
-        {
-                return a<b?a:b;
-        }
-        
-        /**
-         * Finds the lesser of the two objects, objects passed in must be
-         * less-than-comparable.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@returns A reference to the lesser of a or b.
-         */
-        template<typename item>
-        item &buMin( item &a, item &b )
-        {
-                return a<b?a:b;
-        }
-        
-        /**
-         * Finds the greater of the two objects, objects passed in must be
-         * less-than-comparable.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@returns A reference to the greater of a or b.
-         */
-        template<typename item>
-        const item &buMax( const item &a, const item &b )
-        {
-                return b<a?a:b;
-        }
-        
-        /**
-         * Finds the greater of the two objects, objects passed in must be
-         * less-than-comparable.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@returns A reference to the greater of a or b.
-         */
-        template<typename item>
-        item &buMax( item &a, item &b )
-        {
-                return b<a?a:b;
-        }
+    /**
+     * Finds the lesser of the two objects, objects passed in must be
+     * less-than-comparable.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@returns A reference to the lesser of a or b.
+     */
+    template<typename item>
+    const item &buMin( const item &a, const item &b )
+    {
+        return a<b?a:b;
+    }
+    
+    /**
+     * Finds the lesser of the two objects, objects passed in must be
+     * less-than-comparable.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@returns A reference to the lesser of a or b.
+     */
+    template<typename item>
+    item &buMin( item &a, item &b )
+    {
+        return a<b?a:b;
+    }
+    
+    /**
+     * Finds the greater of the two objects, objects passed in must be
+     * less-than-comparable.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@returns A reference to the greater of a or b.
+     */
+    template<typename item>
+    const item &buMax( const item &a, const item &b )
+    {
+        return b<a?a:b;
+    }
+    
+    /**
+     * Finds the greater of the two objects, objects passed in must be
+     * less-than-comparable.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@returns A reference to the greater of a or b.
+     */
+    template<typename item>
+    item &buMax( item &a, item &b )
+    {
+        return b<a?a:b;
+    }
 
-        /**
-         * Given three objects this finds the one between the other two.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@param c Yet another value to test.
-         *@returns A reference to the mid-value of a, b, and c.
-         */
-        template<typename item>
-        const item &buMid( const item &a, const item &b, const item &c )
-        {
-                return buMin( buMax( a, b ), c );
-        }
-                
-        /**
-         * Given three objects this finds the one between the other two.
-         *@param a A value to test.
-         *@param b Another value to test.
-         *@param c Yet another value to test.
-         *@returns A reference to the mid-value of a, b, and c.
-         */
-        template<typename item>
-        item &buMid( item &a, item &b, item &c )
-        {
-                return buMin( buMax( a, b ), c );
-        }
-        
-        //
-        //  Basic comparison functors
-        //
-        /**
-         * Simple less-than comparison functor.  Objects being used should be
-         * less-than-comparable.
-         */
-        template<typename item>
-        struct __basicLTCmp
-        {
-                bool operator()( const item &a, const item &b )
-                {
-                        return a < b;
-                }
-        };
-        
-        /**
-         * Simple greater-than comparison functor.  Objects being used should be
-         * greater-than-comparable.
-         */
-        template<typename item>
-        struct __basicGTCmp
-        {
-                bool operator()( const item &a, const item &b )
-                {
-                        return a > b;
-                }
-        };
+    /**
+     * Given three objects this finds the one between the other two.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@param c Yet another value to test.
+     *@returns A reference to the mid-value of a, b, and c.
+     */
+    template<typename item>
+    const item &buMid( const item &a, const item &b, const item &c )
+    {
+        return buMin( buMax( a, b ), c );
+    }
+        
+    /**
+     * Given three objects this finds the one between the other two.
+     *@param a A value to test.
+     *@param b Another value to test.
+     *@param c Yet another value to test.
+     *@returns A reference to the mid-value of a, b, and c.
+     */
+    template<typename item>
+    item &buMid( item &a, item &b, item &c )
+    {
+        return buMin( buMax( a, b ), c );
+    }
+    
+    //
+    //  Basic comparison functors
+    //
+    /**
+     * Simple less-than comparison functor.  Objects being used should be
+     * less-than-comparable.
+     */
+    template<typename item>
+    struct __basicLTCmp
+    {
+        bool operator()( const item &a, const item &b )
+        {
+            return a < b;
+        }
+    };
+    
+    /**
+     * Simple greater-than comparison functor.  Objects being used should be
+     * greater-than-comparable.
+     */
+    template<typename item>
+    struct __basicGTCmp
+    {
+        bool operator()( const item &a, const item &b )
+        {
+            return a > b;
+        }
+    };
 
-        /**
-         * As __basicLTCmp but dereferences the passed in pointers before comparing.
-         */
-        template<typename item>
-        struct __basicPtrLTCmp
-        {
-                bool operator()( const item &a, const item &b )
-                {
-                        return *a < *b;
-                }
-        };
-        
-        /**
-         * As __basicGTCmp but dereferences the passed in pointers before comparing.
-         */
-        template<typename item>
-        struct __basicPtrGTCmp
-        {
-                bool operator()( const item &a, const item &b )
-                {
-                        return *a > *b;
-                }
-        };
+    /**
+     * As __basicLTCmp but dereferences the passed in pointers before comparing.
+     */
+    template<typename item>
+    struct __basicPtrLTCmp
+    {
+        bool operator()( const item &a, const item &b )
+        {
+            return *a < *b;
+        }
+    };
+    
+    /**
+     * As __basicGTCmp but dereferences the passed in pointers before comparing.
+     */
+    template<typename item>
+    struct __basicPtrGTCmp
+    {
+        bool operator()( const item &a, const item &b )
+        {
+            return *a > *b;
+        }
+    };
 
-        /**
-         * Get the number of days in the month in the gregorian calendar, taking
-         * leap years into account.
-         */
-        int getDaysInMonth( int iMonth, int iYear );
+    /**
+     * Get the number of days in the month in the gregorian calendar, taking
+     * leap years into account.
+     */
+    int getDaysInMonth( int iMonth, int iYear );
 
-        void memcpy( void *pDest, const void *pSrc, size_t iBytes );
+    void memcpy( void *pDest, const void *pSrc, size_t iBytes );
 };
 
 #endif
diff --git a/src/stable/variant.cpp b/src/stable/variant.cpp
index 674ae04..d724fa7 100644
--- a/src/stable/variant.cpp
+++ b/src/stable/variant.cpp
@@ -11,7 +11,7 @@
 
 namespace Bu
 {
-        Formatter &operator<<( Formatter &f, const String &s );
+    Formatter &operator<<( Formatter &f, const String &s );
 };
 
 Bu::VariantTypeRoot::VariantTypeRoot()
@@ -23,84 +23,84 @@ Bu::VariantTypeRoot::~VariantTypeRoot()
 }
 
 Bu::Variant::Variant() :
-        pCore( NULL )
+    pCore( NULL )
 {
 }
 
 Bu::Variant::Variant( const Variant &v ) :
-        pCore( NULL )
+    pCore( NULL )
 {
-        if( v.pCore )
-        {
-                pCore = v.pCore->clone();
-        }
+    if( v.pCore )
+    {
+        pCore = v.pCore->clone();
+    }
 }
 
 Bu::Variant::Variant( const char *t ) :
-        pCore( NULL )
+    pCore( NULL )
 {
-        set( Bu::String( t ) );
+    set( Bu::String( t ) );
 }
 
 Bu::Variant::~Variant()
 {
-        if( pCore )
-        {
-                delete pCore;
-                pCore = NULL;
-        }
+    if( pCore )
+    {
+        delete pCore;
+        pCore = NULL;
+    }
 }
 
 Bu::String Bu::Variant::toString() const
 {
-        if( getType() == typeid( Bu::String ) )
-        {
-                return get<Bu::String>();
-        }
-        else
-        {
-                Bu::MemBuf mb;
-                Bu::Formatter f( mb );
-                f << *this;
-                return mb.getString();
-        }
+    if( getType() == typeid( Bu::String ) )
+    {
+        return get<Bu::String>();
+    }
+    else
+    {
+        Bu::MemBuf mb;
+        Bu::Formatter f( mb );
+        f << *this;
+        return mb.getString();
+    }
 }
 
 bool Bu::Variant::isSet() const
 {
-        return pCore != NULL;
+    return pCore != NULL;
 }
 
 const std::type_info &Bu::Variant::getType() const
 {
-        if( !pCore )
-        {
-                throw Bu::ExceptionBase("No data!");
-        }
-        return pCore->getType();
+    if( !pCore )
+    {
+        throw Bu::ExceptionBase("No data!");
+    }
+    return pCore->getType();
 }
 
 Bu::Variant &Bu::Variant::operator=( const Bu::Variant &rhs )
 {
-        if( pCore )
-        {
-                delete pCore;
-                pCore = NULL;
-        }
-        if( rhs.pCore )
-        {
-                pCore = rhs.pCore->clone();
-        }
-
-        return *this;
+    if( pCore )
+    {
+        delete pCore;
+        pCore = NULL;
+    }
+    if( rhs.pCore )
+    {
+        pCore = rhs.pCore->clone();
+    }
+
+    return *this;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::Variant &v )
 {
-        if( !v.pCore )
-                return f << "(null)";
+    if( !v.pCore )
+        return f << "(null)";
 
-        v.pCore->format( f );
-        return f;
+    v.pCore->format( f );
+    return f;
 }
 
diff --git a/src/stable/variant.h b/src/stable/variant.h
index 6837954..227e246 100644
--- a/src/stable/variant.h
+++ b/src/stable/variant.h
@@ -20,217 +20,217 @@
 
 namespace Bu
 {
-        class String;
-        class Formatter;
-        class Variant;
-        /** @cond DEVEL */
-        template<class t> class VariantType;
-
-        class VariantTypeRoot
-        {
-        public:
-                VariantTypeRoot();
-                virtual ~VariantTypeRoot();
-
-                virtual const std::type_info &getType() const=0;
-                virtual VariantTypeRoot *clone() const=0;
-                virtual void format( Bu::Formatter &f ) const=0;
-        };
-
-        template<class t>
-        class VariantType : public VariantTypeRoot
-        {
-                friend class Variant;
-        private:
-                VariantType()
-                {
-                }
-
-                VariantType( const t &d ) : 
-                        data( d )
-                {
-                }
-
-                VariantType( const VariantType<t> &vt ) :
-                        data( vt.data )
-                {
-                }
-
-                virtual ~VariantType()
-                {
-                }
-
-        public:
-                t &getData()
-                {
-                        return data;
-                }
-                
-                const t &getData() const
-                {
-                        return data;
-                }
-
-                virtual void format( Formatter &f ) const
-                {
-                        f << data;
-                }
-
-                virtual const std::type_info &getType() const
-                {
-                        return typeid( data );
-                }
-
-                VariantType<t> operator=( const t &rhs )
-                {
-                        data = rhs;
-
-                        return *this;
-                }
-
-                virtual VariantTypeRoot *clone() const
-                {
-                        return new VariantType<t>( *this );
-                }
-
-        private:
-                t data;
-        };
-        /** @endcond */
-
-        /**
-         * Store any data type and access it safely.  Variant gives you a way to
-         * pass arbitrary data types around without having to worry about what
-         * type a variable is.  It allows code to be easily extended and to manage
-         * data without having to know what type it is ahead of time.
-         *
-         * Because of the generic method that this class was implemented it may seem
-         * to have some drawbacks compared to other Variant classes you may have
-         * seen, however it is fairly easy to get it to do just about anything you
-         * may need.  It is also very low overhead.  On most compilers the class
-         * itself has only 3 words of overhead + the size of the variable you store
-         * in it.  And, since many parts of it are templatized they can often be
-         * optimized quite a bit.
-         */
-        class Variant
-        {
-        friend Bu::Formatter &operator<<( Bu::Formatter &f, const Variant &v );
-        public:
-                Variant();
-                Variant( const Variant &v );
-                Variant( const char *t );
-                template<class t>
-                Variant( const t &v ) :
-                        pCore( new VariantType<t>() )
-                {
-                        (*dynamic_cast<VariantType<t> *>(pCore)) = v;
-                }
-                virtual ~Variant();
-
-                Bu::String toString() const;
-                bool isSet() const;
-                const std::type_info &getType() const;
-
-                Variant &operator=( const Variant &rhs );
-
-                template<class t>
-                Variant &operator=( const t &rhs )
-                {
-                        if( pCore ) // && pCore->getType() != typeid(t) )
-                        {
-                                delete pCore;
-                                pCore = NULL;
-                        }
-                        pCore = new VariantType<t>();
-                        (*dynamic_cast<VariantType<t> *>(pCore)) = rhs;
-                        return *this;
-                }
-
-                template<class t>
-                t &get()
-                {
-                        if( !pCore )
-                        {
-                                throw Bu::ExceptionBase("No data!");
-                        }
-                        if( pCore->getType() != typeid(t) )
-                        {
-                                throw Bu::ExceptionBase("Invalid type conversion.");
-                        }
-                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
-                }
-                
-                template<class t>
-                t &get() const
-                {
-                        if( !pCore )
-                        {
-                                throw Bu::ExceptionBase("No data!");
-                        }
-                        if( pCore->getType() != typeid(t) )
-                        {
-                                throw Bu::ExceptionBase("Invalid type conversion.");
-                        }
-                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
-                }
-                
-                template<class t>
-                void set( const t &val )
-                {
-                        if( pCore && pCore->getType() != typeid(t) )
-                        {
-                                delete pCore;
-                                pCore = NULL;
-                        }
-                        pCore = new VariantType<t>();
-                        (*dynamic_cast<VariantType<t> *>(pCore)) = val;
-                }
-
-                template<class t>
-                bool isType() const
-                {
-                        return pCore->getType() == typeid(t);
-                }
-
-                template<class t>
-                operator t()
-                {
-                        if( !pCore )
-                        {
-                                throw Bu::ExceptionBase("No data!");
-                        }
-                        if( pCore->getType() != typeid(t) )
-                        {
-                                throw Bu::ExceptionBase("Invalid type conversion.");
-                        }
-                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
-                }
-                
-                template<class t>
-                operator t() const
-                {
-                        if( !pCore )
-                        {
-                                throw Bu::ExceptionBase("No data!");
-                        }
-                        if( pCore->getType() != typeid(t) )
-                        {
-                                throw Bu::ExceptionBase("Invalid type conversion.");
-                        }
-                        return dynamic_cast<VariantType<t> *>(pCore)->getData();
-                }
-
-        private:
-                VariantTypeRoot *pCore;
-        };
+    class String;
+    class Formatter;
+    class Variant;
+    /** @cond DEVEL */
+    template<class t> class VariantType;
+
+    class VariantTypeRoot
+    {
+    public:
+        VariantTypeRoot();
+        virtual ~VariantTypeRoot();
+
+        virtual const std::type_info &getType() const=0;
+        virtual VariantTypeRoot *clone() const=0;
+        virtual void format( Bu::Formatter &f ) const=0;
+    };
+
+    template<class t>
+    class VariantType : public VariantTypeRoot
+    {
+        friend class Variant;
+    private:
+        VariantType()
+        {
+        }
+
+        VariantType( const t &d ) : 
+            data( d )
+        {
+        }
+
+        VariantType( const VariantType<t> &vt ) :
+            data( vt.data )
+        {
+        }
+
+        virtual ~VariantType()
+        {
+        }
+
+    public:
+        t &getData()
+        {
+            return data;
+        }
+        
+        const t &getData() const
+        {
+            return data;
+        }
+
+        virtual void format( Formatter &f ) const
+        {
+            f << data;
+        }
+
+        virtual const std::type_info &getType() const
+        {
+            return typeid( data );
+        }
+
+        VariantType<t> operator=( const t &rhs )
+        {
+            data = rhs;
+
+            return *this;
+        }
+
+        virtual VariantTypeRoot *clone() const
+        {
+            return new VariantType<t>( *this );
+        }
+
+    private:
+        t data;
+    };
+    /** @endcond */
+
+    /**
+     * Store any data type and access it safely.  Variant gives you a way to
+     * pass arbitrary data types around without having to worry about what
+     * type a variable is.  It allows code to be easily extended and to manage
+     * data without having to know what type it is ahead of time.
+     *
+     * Because of the generic method that this class was implemented it may seem
+     * to have some drawbacks compared to other Variant classes you may have
+     * seen, however it is fairly easy to get it to do just about anything you
+     * may need.  It is also very low overhead.  On most compilers the class
+     * itself has only 3 words of overhead + the size of the variable you store
+     * in it.  And, since many parts of it are templatized they can often be
+     * optimized quite a bit.
+     */
+    class Variant
+    {
+    friend Bu::Formatter &operator<<( Bu::Formatter &f, const Variant &v );
+    public:
+        Variant();
+        Variant( const Variant &v );
+        Variant( const char *t );
+        template<class t>
+        Variant( const t &v ) :
+            pCore( new VariantType<t>() )
+        {
+            (*dynamic_cast<VariantType<t> *>(pCore)) = v;
+        }
+        virtual ~Variant();
+
+        Bu::String toString() const;
+        bool isSet() const;
+        const std::type_info &getType() const;
+
+        Variant &operator=( const Variant &rhs );
+
+        template<class t>
+        Variant &operator=( const t &rhs )
+        {
+            if( pCore ) // && pCore->getType() != typeid(t) )
+            {
+                delete pCore;
+                pCore = NULL;
+            }
+            pCore = new VariantType<t>();
+            (*dynamic_cast<VariantType<t> *>(pCore)) = rhs;
+            return *this;
+        }
+
+        template<class t>
+        t &get()
+        {
+            if( !pCore )
+            {
+                throw Bu::ExceptionBase("No data!");
+            }
+            if( pCore->getType() != typeid(t) )
+            {
+                throw Bu::ExceptionBase("Invalid type conversion.");
+            }
+            return dynamic_cast<VariantType<t> *>(pCore)->getData();
+        }
+        
+        template<class t>
+        t &get() const
+        {
+            if( !pCore )
+            {
+                throw Bu::ExceptionBase("No data!");
+            }
+            if( pCore->getType() != typeid(t) )
+            {
+                throw Bu::ExceptionBase("Invalid type conversion.");
+            }
+            return dynamic_cast<VariantType<t> *>(pCore)->getData();
+        }
+        
+        template<class t>
+        void set( const t &val )
+        {
+            if( pCore && pCore->getType() != typeid(t) )
+            {
+                delete pCore;
+                pCore = NULL;
+            }
+            pCore = new VariantType<t>();
+            (*dynamic_cast<VariantType<t> *>(pCore)) = val;
+        }
+
+        template<class t>
+        bool isType() const
+        {
+            return pCore->getType() == typeid(t);
+        }
+
+        template<class t>
+        operator t()
+        {
+            if( !pCore )
+            {
+                throw Bu::ExceptionBase("No data!");
+            }
+            if( pCore->getType() != typeid(t) )
+            {
+                throw Bu::ExceptionBase("Invalid type conversion.");
+            }
+            return dynamic_cast<VariantType<t> *>(pCore)->getData();
+        }
+        
+        template<class t>
+        operator t() const
+        {
+            if( !pCore )
+            {
+                throw Bu::ExceptionBase("No data!");
+            }
+            if( pCore->getType() != typeid(t) )
+            {
+                throw Bu::ExceptionBase("Invalid type conversion.");
+            }
+            return dynamic_cast<VariantType<t> *>(pCore)->getData();
+        }
+
+    private:
+        VariantTypeRoot *pCore;
+    };
 /*
-        template<class t>
-        Bu::Formatter &operator<<( Bu::Formatter &f, const VariantType<t> &vt )
-        {
-                return f << vt.getData;
-        }*/
+    template<class t>
+    Bu::Formatter &operator<<( Bu::Formatter &f, const VariantType<t> &vt )
+    {
+        return f << vt.getData;
+    }*/
 
-        Bu::Formatter &operator<<( Bu::Formatter &f, const Variant &v );
+    Bu::Formatter &operator<<( Bu::Formatter &f, const Variant &v );
 };
 
 #endif