The reorg is being put in trunk, I think it's ready. Now we just get to find

out how many applications won't work anymore :)

122 files changed, 528 insertions, 325 deletions

diff --git a/src/cgi.cpp b/src/old/cgi.cpp
index 1fecbbe..1fecbbe 100644
--- a/src/cgi.cpp
+++ b/src/old/cgi.cpp
diff --git a/src/cgi.h b/src/old/cgi.h
index 01142b5..01142b5 100644
--- a/src/cgi.h
+++ b/src/old/cgi.h
diff --git a/src/configmanagerbase.cpp b/src/old/configmanagerbase.cpp
index ac55fe0..ac55fe0 100644
--- a/src/configmanagerbase.cpp
+++ b/src/old/configmanagerbase.cpp
diff --git a/src/configmanagerbase.h b/src/old/configmanagerbase.h
index 381cc1f..381cc1f 100644
--- a/src/configmanagerbase.h
+++ b/src/old/configmanagerbase.h
diff --git a/src/confpair.cpp b/src/old/confpair.cpp
index 4741401..4741401 100644
--- a/src/confpair.cpp
+++ b/src/old/confpair.cpp
diff --git a/src/confpair.h b/src/old/confpair.h
index 56eb06e..56eb06e 100644
--- a/src/confpair.h
+++ b/src/old/confpair.h
diff --git a/src/confpairbase.cpp b/src/old/confpairbase.cpp
index 1203dc0..1203dc0 100644
--- a/src/confpairbase.cpp
+++ b/src/old/confpairbase.cpp
diff --git a/src/confpairbase.h b/src/old/confpairbase.h
index 2530756..2530756 100644
--- a/src/confpairbase.h
+++ b/src/old/confpairbase.h
diff --git a/src/conftree.cpp b/src/old/conftree.cpp
index d9a3a3f..d9a3a3f 100644
--- a/src/conftree.cpp
+++ b/src/old/conftree.cpp
diff --git a/src/conftree.h b/src/old/conftree.h
index 197b1ef..197b1ef 100644
--- a/src/conftree.h
+++ b/src/old/conftree.h
diff --git a/src/connection.cpp b/src/old/connection.cpp
index efef144..efef144 100644
--- a/src/connection.cpp
+++ b/src/old/connection.cpp
diff --git a/src/connection.h b/src/old/connection.h
index 0e991c7..0e991c7 100644
--- a/src/connection.h
+++ b/src/old/connection.h
diff --git a/src/connectionmanager.cpp b/src/old/connectionmanager.cpp
index ea60b2b..ea60b2b 100644
--- a/src/connectionmanager.cpp
+++ b/src/old/connectionmanager.cpp
diff --git a/src/connectionmanager.h b/src/old/connectionmanager.h
index cff036b..cff036b 100644
--- a/src/connectionmanager.h
+++ b/src/old/connectionmanager.h
diff --git a/src/connectionmonitor.cpp b/src/old/connectionmonitor.cpp
index 4f90ee6..4f90ee6 100644
--- a/src/connectionmonitor.cpp
+++ b/src/old/connectionmonitor.cpp
diff --git a/src/connectionmonitor.h b/src/old/connectionmonitor.h
index 9910556..9910556 100644
--- a/src/connectionmonitor.h
+++ b/src/old/connectionmonitor.h
diff --git a/src/flexbuf.cpp b/src/old/flexbuf.cpp
index 6d55294..6d55294 100644
--- a/src/flexbuf.cpp
+++ b/src/old/flexbuf.cpp
diff --git a/src/flexbuf.h b/src/old/flexbuf.h
index 7d7f11a..7d7f11a 100644
--- a/src/flexbuf.h
+++ b/src/old/flexbuf.h
diff --git a/src/formula.cpp b/src/old/formula.cpp
index cf63cf3..cf63cf3 100644
--- a/src/formula.cpp
+++ b/src/old/formula.cpp
diff --git a/src/formula.h b/src/old/formula.h
index 939eb09..939eb09 100644
--- a/src/formula.h
+++ b/src/old/formula.h
diff --git a/src/http.cpp b/src/old/http.cpp
index df7dafe..df7dafe 100644
--- a/src/http.cpp
+++ b/src/old/http.cpp
diff --git a/src/http.h b/src/old/http.h
index 7e9f9a0..7e9f9a0 100644
--- a/src/http.h
+++ b/src/old/http.h
diff --git a/src/httpget.cpp b/src/old/httpget.cpp
index ee1f29c..ee1f29c 100644
--- a/src/httpget.cpp
+++ b/src/old/httpget.cpp
diff --git a/src/httpget.h b/src/old/httpget.h
index 8272641..8272641 100644
--- a/src/httpget.h
+++ b/src/old/httpget.h
diff --git a/src/linkedlist.cpp b/src/old/linkedlist.cpp
index a9902bc..a9902bc 100644
--- a/src/linkedlist.cpp
+++ b/src/old/linkedlist.cpp
diff --git a/src/linkedlist.h b/src/old/linkedlist.h
index e430108..e430108 100644
--- a/src/linkedlist.h
+++ b/src/old/linkedlist.h
diff --git a/src/linkmessenger.cpp b/src/old/linkmessenger.cpp
index 3bd401a..3bd401a 100644
--- a/src/linkmessenger.cpp
+++ b/src/old/linkmessenger.cpp
diff --git a/src/linkmessenger.h b/src/old/linkmessenger.h
index ed52639..ed52639 100644
--- a/src/linkmessenger.h
+++ b/src/old/linkmessenger.h
diff --git a/src/old/list.cpp b/src/old/list.cpp
new file mode 100644
index 0000000..18f1a66
--- /dev/null
+++ b/src/old/list.cpp
@@ -0,0 +1,10 @@
+#include "list.h"
+
+List::List(  )
+{
+}
+
+List::~List(  )
+{
+}
+
diff --git a/src/old/list.h b/src/old/list.h
new file mode 100644
index 0000000..c71b328
--- /dev/null
+++ b/src/old/list.h
@@ -0,0 +1,101 @@
+#ifndef LIST_H
+#define LIST_H
+
+
+/** The basic List class ADT.  This, on it's own, does absolutely nothing, but
+  * does define all standard interface functions to access a list.
+  *@author Mike Buland
+  */
+class List
+{
+public:
+        /**
+         * Construct a list.
+         */
+        List();
+
+        /**
+         * Desconstruct a list.
+         */
+        virtual ~List();
+
+        /** Gets the value at a specified index.
+          *@param nIndex The index of the item to return.
+          *@returns The specified item, or NULL if the index was beyond the range
+          * of the list.
+          *@author Mike Buland
+          */
+        virtual void *getAt( int nIndex ) = 0;
+
+        /** Append the given data to the end of the list.  This increases the
+          * size of the list by one.
+          *@param pData The data to append to the list.
+          *@author Mike Buland
+          */
+        virtual void append( void *pData ) = 0;
+
+        /** Inserts an item at the specified position in the list.  The
+          * new item takes the index that you specify, and all other items
+          * are moved up one position.  The size of the list is increased by
+          * one.
+          *@param pData The value to insert into the list.
+          *@param nPos Where to insert the data into the list.
+          *@author Mike Buland
+          */
+        virtual void insertBefore( void *pData, int nPos = 0 ) = 0;
+
+        /** Determines the size of the list, in elements.
+          *@returns The size of the list.
+          *@author Mike Buland
+          */
+        virtual int getSize(  ) = 0;
+
+        /** Determines if the list is empty or not.
+          *@returns True if the list is empty, or false if the list has
+          * data in it (if the size is greater than zero).
+          *@author Mike Buland
+          */
+        virtual bool isEmpty(  ) = 0;
+
+        /** Deletes an item at the specified index and moves all other
+          * values down one index.  The size of the list is decreased by one.
+          *@param nIndex The index of the item to delete.
+          *@author Mike Buland
+          */
+        virtual void deleteAt( int nIndex ) = 0;
+
+        /** Completely empties the list, and sets the effective size to
+          * zero.
+          *@author Mike Buland
+          */
+        virtual void empty() = 0;
+
+        /** Sets the size of the list.  This can be larger or smaller
+          * than what it was previously.  If larger, new blank items will
+          * be added to the end of the list.  If smaller than the old list
+          * items will be deleted from the end.
+          *@param nNewSize The new size of the list.
+          *@author Mike Buland
+          */
+        virtual void setSize( int nNewSize ) = 0;
+
+        /** Sets a member at a specified location to a new value.
+          * If the member being set is outside of the range of the
+          * current list it should be expanded.
+          *@param nIndex The zero-based index of the item to change.
+          *@param pData The new value for that index.
+          *@author Mike Buland
+          */
+        virtual void setAt( int nIndex, void *pData ) = 0;
+
+        /** Makes the List work like an array.  Just say listObj[2] to get
+          * the third element.
+          *@param nIndex The index to access in the list.
+          *@returns A pointer to the data at element index.
+          *@author Mike Buland
+          */
+        void *operator[]( int nIndex ) { return getAt( nIndex ); };
+};
+
+#endif
+
diff --git a/src/md5.cpp b/src/old/md5.cpp
index c0cacdd..c0cacdd 100644
--- a/src/md5.cpp
+++ b/src/old/md5.cpp
diff --git a/src/md5.h b/src/old/md5.h
index 7f77d83..7f77d83 100644
--- a/src/md5.h
+++ b/src/old/md5.h
diff --git a/src/multilog.cpp b/src/old/multilog.cpp
index 143ee89..143ee89 100644
--- a/src/multilog.cpp
+++ b/src/old/multilog.cpp
diff --git a/src/multilog.h b/src/old/multilog.h
index 692095a..692095a 100644
--- a/src/multilog.h
+++ b/src/old/multilog.h
diff --git a/src/multilogchannel.cpp b/src/old/multilogchannel.cpp
index ee4c9bf..ee4c9bf 100644
--- a/src/multilogchannel.cpp
+++ b/src/old/multilogchannel.cpp
diff --git a/src/multilogchannel.h b/src/old/multilogchannel.h
index d891a65..d891a65 100644
--- a/src/multilogchannel.h
+++ b/src/old/multilogchannel.h
diff --git a/src/multilogtext.cpp b/src/old/multilogtext.cpp
index 4337cc9..4337cc9 100644
--- a/src/multilogtext.cpp
+++ b/src/old/multilogtext.cpp
diff --git a/src/multilogtext.h b/src/old/multilogtext.h
index 197aef1..197aef1 100644
--- a/src/multilogtext.h
+++ b/src/old/multilogtext.h
diff --git a/src/ordhash.cpp b/src/old/ordhash.cpp
index 77cbd61..77cbd61 100644
--- a/src/ordhash.cpp
+++ b/src/old/ordhash.cpp
diff --git a/src/ordhash.h b/src/old/ordhash.h
index e946f95..e946f95 100644
--- a/src/ordhash.h
+++ b/src/old/ordhash.h
diff --git a/src/pqueue.cpp b/src/old/pqueue.cpp
index 1f0b8b5..1f0b8b5 100644
--- a/src/pqueue.cpp
+++ b/src/old/pqueue.cpp
diff --git a/src/pqueue.h b/src/old/pqueue.h
index 8307d56..8307d56 100644
--- a/src/pqueue.h
+++ b/src/old/pqueue.h
diff --git a/src/old/protocol.cpp b/src/old/protocol.cpp
new file mode 100644
index 0000000..78b3ee2
--- /dev/null
+++ b/src/old/protocol.cpp
@@ -0,0 +1,20 @@
+#include "protocol.h"
+
+Protocol::Protocol()
+{
+        pConnection = NULL;
+}
+
+Protocol::~Protocol()
+{
+}
+
+void Protocol::setConnection( Connection *pNewConnection )
+{
+        pConnection = pNewConnection;
+}
+
+Connection *Protocol::getConnection()
+{
+        return pConnection;
+}
diff --git a/src/old/protocol.h b/src/old/protocol.h
new file mode 100644
index 0000000..09e1c98
--- /dev/null
+++ b/src/old/protocol.h
@@ -0,0 +1,62 @@
+#ifndef PROTOCOL_H
+#define PROTOCOL_H
+
+#include "connection.h"
+
+/** This is the template for a class that handles specialized input and output
+  * to connections of different types with different protocols.
+  *@author Mike Buland
+  */
+class Protocol
+{
+public:
+        /** Constructor */
+    Protocol();
+        /** Deconstructor */
+    virtual ~Protocol();
+
+        /**
+         * Function is called every time there is new data on the line.  This is
+         * called directly from the Connection class to process data.  This is not
+         * called whever there is pending data on the input, but every time new data
+         * is added to the input buffer.
+         *@returns True if processing went alright, false if something went wrong,
+         * I suppose.  In truth this value is thrown away right now.
+         *@todo Either make a return value of false mean something, or make these
+         * void.
+         */
+        virtual bool onNewData()=0;
+
+        /**
+         * Function is called when there is a new connection.  This should only
+         * happen once per Protocol object, but gives each protocol object a
+         * chance to perform connection handshaking and initialization at a point
+         * where they know that they have a handle to an active Connection.
+         *@returns See onNewData
+         */
+        virtual bool onNewConnection()=0;
+
+        virtual void onNewClientConnection(){};
+
+        virtual void poll(){};
+
+        /**
+         * Sets the Protocol's Connection object.  This is rather important, and
+         * handled usually by the ConnectionManager.
+         *@param pNewConnection The Connection object that this protocol will use to
+         * deal with the outside world.
+         */
+        void setConnection( class Connection *pNewConnection );
+
+        /**
+         * Get a pointer to this object's Connection object, or NULL if one was
+         * never set.  If used with the ConnectionManager that should never happen.
+         *@returns A pointer to the active Connection.
+         */
+        Connection *getConnection();
+
+private:
+        class Connection *pConnection; /**< The pointer to the Connection. */
+};
+
+#endif
diff --git a/src/protocoltelnet.cpp b/src/old/protocoltelnet.cpp
index b169a51..b169a51 100644
--- a/src/protocoltelnet.cpp
+++ b/src/old/protocoltelnet.cpp
diff --git a/src/protocoltelnet.h b/src/old/protocoltelnet.h
index a6d2e49..a6d2e49 100644
--- a/src/protocoltelnet.h
+++ b/src/old/protocoltelnet.h
diff --git a/src/queue.cpp b/src/old/queue.cpp
index 42999fe..42999fe 100644
--- a/src/queue.cpp
+++ b/src/old/queue.cpp
diff --git a/src/queue.h b/src/old/queue.h
index 692f5d8..692f5d8 100644
--- a/src/queue.h
+++ b/src/old/queue.h
diff --git a/src/ringlist.cpp b/src/old/ringlist.cpp
index 9efbbc4..9efbbc4 100644
--- a/src/ringlist.cpp
+++ b/src/old/ringlist.cpp
diff --git a/src/ringlist.h b/src/old/ringlist.h
index bc069f3..bc069f3 100644
--- a/src/ringlist.h
+++ b/src/old/ringlist.h
diff --git a/src/sbuffer.cpp b/src/old/sbuffer.cpp
index f84f8a3..f84f8a3 100644
--- a/src/sbuffer.cpp
+++ b/src/old/sbuffer.cpp
diff --git a/src/sbuffer.h b/src/old/sbuffer.h
index 65feb71..65feb71 100644
--- a/src/sbuffer.h
+++ b/src/old/sbuffer.h
diff --git a/src/serializerbinary.cpp b/src/old/serializerbinary.cpp
index ea7ed93..ea7ed93 100644
--- a/src/serializerbinary.cpp
+++ b/src/old/serializerbinary.cpp
diff --git a/src/serializerbinary.h b/src/old/serializerbinary.h
index 8510fcd..8510fcd 100644
--- a/src/serializerbinary.h
+++ b/src/old/serializerbinary.h
diff --git a/src/serializerbzip2.cpp b/src/old/serializerbzip2.cpp
index bafabc8..bafabc8 100644
--- a/src/serializerbzip2.cpp
+++ b/src/old/serializerbzip2.cpp
diff --git a/src/serializerbzip2.h b/src/old/serializerbzip2.h
index 4aeb22e..4aeb22e 100644
--- a/src/serializerbzip2.h
+++ b/src/old/serializerbzip2.h
diff --git a/src/serializerconnection.cpp b/src/old/serializerconnection.cpp
index 2934c8b..2934c8b 100644
--- a/src/serializerconnection.cpp
+++ b/src/old/serializerconnection.cpp
diff --git a/src/serializerconnection.h b/src/old/serializerconnection.h
index e8d85c6..e8d85c6 100644
--- a/src/serializerconnection.h
+++ b/src/old/serializerconnection.h
diff --git a/src/serializertext.cpp b/src/old/serializertext.cpp
index 9cf4394..9cf4394 100644
--- a/src/serializertext.cpp
+++ b/src/old/serializertext.cpp
diff --git a/src/serializertext.h b/src/old/serializertext.h
index 01b7f7b..01b7f7b 100644
--- a/src/serializertext.h
+++ b/src/old/serializertext.h
diff --git a/src/sha1.cpp b/src/old/sha1.cpp
index 8270c3b..8270c3b 100644
--- a/src/sha1.cpp
+++ b/src/old/sha1.cpp
diff --git a/src/sha1.h b/src/old/sha1.h
index ab6081d..ab6081d 100644
--- a/src/sha1.h
+++ b/src/old/sha1.h
diff --git a/src/stack.cpp b/src/old/stack.cpp
index 8d9565c..8d9565c 100644
--- a/src/stack.cpp
+++ b/src/old/stack.cpp
diff --git a/src/stack.h b/src/old/stack.h
index 30e2a19..30e2a19 100644
--- a/src/stack.h
+++ b/src/old/stack.h
diff --git a/src/staticstring.cpp b/src/old/staticstring.cpp
index 60f130f..60f130f 100644
--- a/src/staticstring.cpp
+++ b/src/old/staticstring.cpp
diff --git a/src/staticstring.h b/src/old/staticstring.h
index 4c3f7b8..4c3f7b8 100644
--- a/src/staticstring.h
+++ b/src/old/staticstring.h
diff --git a/src/stringrep.cpp b/src/old/stringrep.cpp
index a505f8a..a505f8a 100644
--- a/src/stringrep.cpp
+++ b/src/old/stringrep.cpp
diff --git a/src/stringrep.h b/src/old/stringrep.h
index eaa4a12..eaa4a12 100644
--- a/src/stringrep.h
+++ b/src/old/stringrep.h
diff --git a/src/tests/clistress.cpp b/src/old/tests/clistress.cpp
index 6b0ac66..6b0ac66 100644
--- a/src/tests/clistress.cpp
+++ b/src/old/tests/clistress.cpp
diff --git a/src/tests/confpair.cpp b/src/old/tests/confpair.cpp
index fb1b0d3..fb1b0d3 100644
--- a/src/tests/confpair.cpp
+++ b/src/old/tests/confpair.cpp
diff --git a/src/tests/connect.cpp b/src/old/tests/connect.cpp
index a9fca64..a9fca64 100644
--- a/src/tests/connect.cpp
+++ b/src/old/tests/connect.cpp
diff --git a/src/tests/exception.cpp b/src/old/tests/exception.cpp
index 6417692..6417692 100644
--- a/src/tests/exception.cpp
+++ b/src/old/tests/exception.cpp
diff --git a/src/tests/formula.cpp b/src/old/tests/formula.cpp
index 976b039..976b039 100644
--- a/src/tests/formula.cpp
+++ b/src/old/tests/formula.cpp
diff --git a/src/old/tests/hash.cpp b/src/old/tests/hash.cpp
new file mode 100644
index 0000000..2fc6968
--- /dev/null
+++ b/src/old/tests/hash.cpp
@@ -0,0 +1,116 @@
+#include "hash.h"
+#include "staticstring.h"
+
+int main()
+{
+        const char *names[]={
+                "Homer the Great",
+                "And Maggie Makes Three",
+                "Bart's Comet",
+                "Homie The Clown",
+                "Bart Vs Australia",
+                "Homer vs Patty and Selma",
+                "A star is burns",
+                "Lisa's Wedding",
+                "Two Dozen and One Greyhounds",
+                "The PTA Disbands",
+                "Round Springfield",
+                "The Springfield connection",
+                "Lemon of Troy",
+                "Who Shot Mr. Burns (Pt. 1)",
+                "Who Shot Mr. Burns (pt. 2)",
+                "Radioactive Man",
+                "Home Sweet Homediddly-dum-doodly",
+                "Bart Sells His Soul",
+                "Lisa the Vegetarian",
+                "Treehouse of horror VI",
+                "King Size Homer",
+                "Mother Simpson",
+                "Sideshow Bob's Last Gleaming",
+                "The Simpson's 138th Show Spectacular",
+                "Marge Be Not Proud",
+                "Team Homer",
+                "Two Bad Neighbors",
+                "Scenes From the Class Struggle in Springfield",
+                "Bart the Fink",
+                "Lisa the Iconoclast",
+                "Homer the Smithers",
+                "The Day the Violence Died",
+                "A Fish Called Selma",
+                "Bart on the road",
+                "22 Short Films about Springfield",
+                "The Curse of the Flying Hellfish",
+                "Much Apu about Nothing",
+                "Homerpalooza",
+                "The Summer of 4 Ft 2",
+                "Treehouse of Horror VII",
+                "You Only Move Twice",
+                "The Homer They Fall",
+                "Burns Baby Burns",
+                "Bart After Dark",
+                "A Millhouse Divided",
+                "Lisas Date With Destiny",
+                "Hurricane Neddy",
+                "The Mysterious Voyage of Our Homer",
+                "The Springfield Files",
+                "The Twisted World of Marge Simpson",
+                "Mountain of Madness",
+                NULL
+        };
+
+        Hash<const char *, int> sTest;
+
+        printf("Inserting\n-------------------\n\n");
+        for( int j = 0; j < 33; j++ )
+        {
+                sTest[names[j]] = j;
+        }
+        
+        printf("Test1: %d, Test2: %d\n", sTest.has("Lemon of Troy"), sTest.has(std::string("Lemon of Troy").c_str() ) );
+
+        sTest.has(std::string("Lemon of Troy").c_str() );
+
+        printf("Getting\n-------------------\n\n");
+
+        sTest.erase("Homer the Great");
+        sTest["Bart's Comet"].erase();
+
+        for( Hash<const char *, int>::iterator i = sTest.begin();
+                 i != sTest.end(); i++ )
+        {
+                Hash<const char *, int>::iterator j = i;
+                printf("%d: %s\n", (*j).second, (*j).first );
+        }
+
+        printf("Testing\n-------------------\n\n");
+        for( int j = 0; j < 33; j++ )
+        {
+                if( sTest.has(names[j]) )
+                {
+                        if( sTest[names[j]] != j )
+                        {
+                                printf("'%s' should be %d, is %d\n",
+                                        names[j], j,
+                                        sTest[names[j]].value()
+                                        );
+                        }
+                }
+                else
+                {
+                        printf("Missing element %d, '%s'\n", j, names[j] );
+                }
+        }
+
+        printf("Clearing\n-------------------\n\n");
+
+        sTest.clear();
+        
+        for( Hash<const char *, int>::iterator i = sTest.begin();
+                 i != sTest.end(); i++ )
+        {
+                Hash<const char *, int>::iterator j = i;
+                printf("%d: %s\n", (*j).second, (*j).first );
+        }
+
+}
+
diff --git a/src/tests/hashtest.cpp b/src/old/tests/hashtest.cpp
index eaa84a0..eaa84a0 100644
--- a/src/tests/hashtest.cpp
+++ b/src/old/tests/hashtest.cpp
diff --git a/src/tests/hashtest2.cpp b/src/old/tests/hashtest2.cpp
index 74700fd..74700fd 100644
--- a/src/tests/hashtest2.cpp
+++ b/src/old/tests/hashtest2.cpp
diff --git a/src/tests/httpsrv/httpconnectionmonitor.cpp b/src/old/tests/httpsrv/httpconnectionmonitor.cpp
index 51d82f3..51d82f3 100644
--- a/src/tests/httpsrv/httpconnectionmonitor.cpp
+++ b/src/old/tests/httpsrv/httpconnectionmonitor.cpp
diff --git a/src/tests/httpsrv/httpconnectionmonitor.h b/src/old/tests/httpsrv/httpconnectionmonitor.h
index 30c0afd..30c0afd 100644
--- a/src/tests/httpsrv/httpconnectionmonitor.h
+++ b/src/old/tests/httpsrv/httpconnectionmonitor.h
diff --git a/src/tests/httpsrv/main.cpp b/src/old/tests/httpsrv/main.cpp
index 2f1563c..2f1563c 100644
--- a/src/tests/httpsrv/main.cpp
+++ b/src/old/tests/httpsrv/main.cpp
diff --git a/src/tests/log.cpp b/src/old/tests/log.cpp
index d7cfa0b..d7cfa0b 100644
--- a/src/tests/log.cpp
+++ b/src/old/tests/log.cpp
diff --git a/src/tests/md5test.cpp b/src/old/tests/md5test.cpp
index 6f832df..6f832df 100644
--- a/src/tests/md5test.cpp
+++ b/src/old/tests/md5test.cpp
diff --git a/src/tests/ordhash.cpp b/src/old/tests/ordhash.cpp
index f1d96ec..f1d96ec 100644
--- a/src/tests/ordhash.cpp
+++ b/src/old/tests/ordhash.cpp
diff --git a/src/tests/param.cpp b/src/old/tests/param.cpp
index a4d2824..a4d2824 100644
--- a/src/tests/param.cpp
+++ b/src/old/tests/param.cpp
diff --git a/src/tests/param.h b/src/old/tests/param.h
index 2756b69..2756b69 100644
--- a/src/tests/param.h
+++ b/src/old/tests/param.h
diff --git a/src/tests/plugin/main.cpp b/src/old/tests/plugin/main.cpp
index 51c8390..51c8390 100644
--- a/src/tests/plugin/main.cpp
+++ b/src/old/tests/plugin/main.cpp
diff --git a/src/tests/plugin/plugin.cpp b/src/old/tests/plugin/plugin.cpp
index ea558fd..ea558fd 100644
--- a/src/tests/plugin/plugin.cpp
+++ b/src/old/tests/plugin/plugin.cpp
diff --git a/src/tests/plugin/plugin.h b/src/old/tests/plugin/plugin.h
index f726867..f726867 100644
--- a/src/tests/plugin/plugin.h
+++ b/src/old/tests/plugin/plugin.h
diff --git a/src/tests/qsort.cpp b/src/old/tests/qsort.cpp
index 28c6f03..28c6f03 100644
--- a/src/tests/qsort.cpp
+++ b/src/old/tests/qsort.cpp
diff --git a/src/tests/sbuffer.cpp b/src/old/tests/sbuffer.cpp
index 02798cb..02798cb 100644
--- a/src/tests/sbuffer.cpp
+++ b/src/old/tests/sbuffer.cpp
diff --git a/src/tests/serialize.cpp b/src/old/tests/serialize.cpp
index e233704..e233704 100644
--- a/src/tests/serialize.cpp
+++ b/src/old/tests/serialize.cpp
diff --git a/src/tests/serializetext.cpp b/src/old/tests/serializetext.cpp
index f6be7d3..f6be7d3 100644
--- a/src/tests/serializetext.cpp
+++ b/src/old/tests/serializetext.cpp
diff --git a/src/tests/sha1.cpp b/src/old/tests/sha1.cpp
index df3113c..df3113c 100644
--- a/src/tests/sha1.cpp
+++ b/src/old/tests/sha1.cpp
diff --git a/src/tests/sptr.cpp b/src/old/tests/sptr.cpp
index 252463b..38d3675 100644
--- a/src/tests/sptr.cpp
+++ b/src/old/tests/sptr.cpp
@@ -9,12 +9,12 @@ public:
                 printf("Created.\n");
         }
 
-        virtual ~Annoy()
+        ~Annoy()
         {
                 printf("Destroyed.\n");
         }
 
-        virtual void go()
+        void go()
         {
                 printf("%d: I'm annoying.\n", ++nCnt);
         }
@@ -22,22 +22,6 @@ public:
         int nCnt;
 };
 
-class Annoy2: public Annoy
-{
-public:
-        Annoy2(){};
-        virtual ~Annoy2(){};
-        virtual void go()
-        {
-                printf("{{I'm Annoy2!!}} ");
-                Annoy::go();
-        }
-        virtual void go2()
-        {
-                printf("This is me, on my own...\n");
-        }
-};
-
 void beAnnoying( SPtr<Annoy> bob )
 {
         printf("bob-Count: %d\n", bob.count() );
@@ -46,7 +30,7 @@ void beAnnoying( SPtr<Annoy> bob )
 
 int main()
 {
-        SPtr<Annoy> pt( new Annoy2 );
+        SPtr<Annoy> pt( new Annoy );
         printf("Count: %d\n", pt.count() );
         pt->go();
 
@@ -63,14 +47,6 @@ int main()
                         pt3->go();
 
                         beAnnoying( pt3 );
-
-                        {
-                                SPtr<Annoy2> pt4( SPtrCast<Annoy2>( pt3 ) );
-                                printf("Count: %d\n", pt4.count() );
-
-                                pt4->go2();
-                        }
-                        printf("Count: %d\n", pt.count() );
                 }
                 printf("Count: %d\n", pt.count() );
         }
diff --git a/src/tests/srvstress.cpp b/src/old/tests/srvstress.cpp
index d9a9a1c..d9a9a1c 100644
--- a/src/tests/srvstress.cpp
+++ b/src/old/tests/srvstress.cpp
diff --git a/src/tests/strhash.cpp b/src/old/tests/strhash.cpp
index f6528ca..f6528ca 100644
--- a/src/tests/strhash.cpp
+++ b/src/old/tests/strhash.cpp
diff --git a/src/tests/teltest/main.cpp b/src/old/tests/teltest/main.cpp
index 5d3ec26..5d3ec26 100644
--- a/src/tests/teltest/main.cpp
+++ b/src/old/tests/teltest/main.cpp
diff --git a/src/tests/teltest/telnetmonitor.cpp b/src/old/tests/teltest/telnetmonitor.cpp
index 65954eb..65954eb 100644
--- a/src/tests/teltest/telnetmonitor.cpp
+++ b/src/old/tests/teltest/telnetmonitor.cpp
diff --git a/src/tests/teltest/telnetmonitor.h b/src/old/tests/teltest/telnetmonitor.h
index ba5761e..ba5761e 100644
--- a/src/tests/teltest/telnetmonitor.h
+++ b/src/old/tests/teltest/telnetmonitor.h
diff --git a/src/tests/xmlreadtest.cpp b/src/old/tests/xmlreadtest.cpp
index d061810..d061810 100644
--- a/src/tests/xmlreadtest.cpp
+++ b/src/old/tests/xmlreadtest.cpp
diff --git a/src/tests/xmlrepltest.cpp b/src/old/tests/xmlrepltest.cpp
index 9667705..9667705 100644
--- a/src/tests/xmlrepltest.cpp
+++ b/src/old/tests/xmlrepltest.cpp
diff --git a/src/tests/xmlwritetest.cpp b/src/old/tests/xmlwritetest.cpp
index a22d19d..a22d19d 100644
--- a/src/tests/xmlwritetest.cpp
+++ b/src/old/tests/xmlwritetest.cpp
diff --git a/src/tokenstring.cpp b/src/old/tokenstring.cpp
index e57ba69..e57ba69 100644
--- a/src/tokenstring.cpp
+++ b/src/old/tokenstring.cpp
diff --git a/src/tokenstring.h b/src/old/tokenstring.h
index 42f7309..42f7309 100644
--- a/src/tokenstring.h
+++ b/src/old/tokenstring.h
diff --git a/src/tqsort.h b/src/old/tqsort.h
index c836b4f..c836b4f 100644
--- a/src/tqsort.h
+++ b/src/old/tqsort.h
diff --git a/src/unit/hashtable/hashtable.cpp b/src/old/unit/hashtable/hashtable.cpp
index b2e1cf5..b2e1cf5 100644
--- a/src/unit/hashtable/hashtable.cpp
+++ b/src/old/unit/hashtable/hashtable.cpp
diff --git a/src/unit/xml/xml.cpp b/src/old/unit/xml/xml.cpp
index e4d779c..e4d779c 100644
--- a/src/unit/xml/xml.cpp
+++ b/src/old/unit/xml/xml.cpp
diff --git a/src/xmldocument.cpp b/src/old/xmldocument.cpp
index d7867d5..95b9788 100644
--- a/src/xmldocument.cpp
+++ b/src/old/xmldocument.cpp
@@ -1,6 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include "xmlwriter.h"
+#include "xmldocument.h"
 
 XmlDocument::XmlDocument( XmlNode *pRoot )
 {
@@ -17,28 +17,23 @@ XmlDocument::~XmlDocument()
         }
 }
 
-void XmlDocument::addNode( const char *sName, const char *sContent, bool bClose )
+void XmlDocument::addNode( const Bu::FString &sName )
 {
         if( pRoot == NULL )
         {
                 // This is the first node, so ignore position and just insert it.
-                pCurrent = pRoot = new XmlNode( sName, NULL, sContent );
+                pCurrent = pRoot = new XmlNode( sName );
         }
         else
         {
-                pCurrent = pCurrent->addChild( sName, sContent );
-        }
-
-        if( bClose )
-        {
-                closeNode();
+                pCurrent = pCurrent->addChild( sName );
         }
 }
-
+/*
 void XmlDocument::setName( const char *sName )
 {
         pCurrent->setName( sName );
-}
+}*/
 
 bool XmlDocument::isCompleted()
 {
@@ -143,7 +138,8 @@ void XmlDocument::setContent( const char *sContent )
 {
         if( pCurrent )
         {
-                pCurrent->setContent( sContent );
+                printf("XmlDocument::setContent:  not yet implemented.\n");
+                //pCurrent->setContent( sContent );
         }
 }
 
diff --git a/src/xmldocument.h b/src/old/xmldocument.h
index 6671c41..e0c36eb 100644
--- a/src/xmldocument.h
+++ b/src/old/xmldocument.h
@@ -39,13 +39,7 @@ public:
          * the node and setting the content and name.  If this is set to true the
          * node is appended, but the context node doesn't change.
          */
-        void addNode( const char *sName=NULL, const char *sContent=NULL, bool bClose=false );
-
-        /**
-         * Set the name of the current node context.
-         *@param sName The new name of the node.
-         */
-        void setName( const char *sName );
+        void addNode( const Bu::FString &sName );
 
         /**
          * Close the current node context.  This will move the current context to
diff --git a/src/xmlfilereader.cpp b/src/old/xmlfilereader.cpp
index ed674a8..ed674a8 100644
--- a/src/xmlfilereader.cpp
+++ b/src/old/xmlfilereader.cpp
diff --git a/src/xmlfilereader.h b/src/old/xmlfilereader.h
index e3e02c2..e3e02c2 100644
--- a/src/xmlfilereader.h
+++ b/src/old/xmlfilereader.h
diff --git a/src/xmlfilewriter.cpp b/src/old/xmlfilewriter.cpp
index 3c6fb41..3c6fb41 100644
--- a/src/xmlfilewriter.cpp
+++ b/src/old/xmlfilewriter.cpp
diff --git a/src/xmlfilewriter.h b/src/old/xmlfilewriter.h
index e328f96..e328f96 100644
--- a/src/xmlfilewriter.h
+++ b/src/old/xmlfilewriter.h
diff --git a/src/xmlnode.cpp b/src/old/xmlnode.cpp
index b1ed9a9..96d5850 100644
--- a/src/xmlnode.cpp
+++ b/src/old/xmlnode.cpp
@@ -1,53 +1,15 @@
 #include "xmlnode.h"
-#include "hashfunctionstring.h"
 
-XmlNode::XmlNode( const char *sName, XmlNode *pParent, const char *sContent ) :
-        hProperties( new HashFunctionString(), 53, false ),
-        hChildren( new HashFunctionString(), 53, true )
+XmlNode::XmlNode( const Bu::FString &sName, XmlNode *pParent ) :
+        sName( sName ),
+        pParent( pParent )
 {
-        this->pParent = pParent;
-        if( sName != NULL )
-        {
-                setName( sName );
-        }
-        if( sContent != NULL )
-        {
-                this->sPreContent = new std::string( sContent );
-        }
-        else
-        {
-                this->sPreContent = NULL;
-        }
-        nCurContent = 0;
 }
 
 XmlNode::~XmlNode()
 {
-        for( int j = 0; j < lChildren.getSize(); j++ )
-        {
-                delete (XmlNode *)lChildren[j];
-        }
-        for( int j = 0; j < lPropNames.getSize(); j++ )
-        {
-                delete (std::string *)lPropNames[j];
-        }
-        for( int j = 0; j < lPropValues.getSize(); j++ )
-        {
-                delete (std::string *)lPropValues[j];
-        }
-        for( int j = 0; j < lPostContent.getSize(); j++ )
-        {
-                if( lPostContent[j] != NULL )
-                {
-                        delete (std::string *)lPostContent[j];
-                }
-        }
-        if( sPreContent )
-        {
-                delete sPreContent;
-        }
 }
-
+/*
 void XmlNode::setName( const char *sName )
 {
         if( pParent )
@@ -120,18 +82,18 @@ const char *XmlNode::getContent( int nIndex )
         }
 
         return NULL;
-}
+}*/
 
-XmlNode *XmlNode::addChild( const char *sName, const char *sContent )
+XmlNode *XmlNode::addChild( const Bu::FString &sName )
 {
-        return addChild( new XmlNode( sName, this, sContent ) );
+        return addChild( new XmlNode( sName, this ) );
 }
 
 XmlNode *XmlNode::addChild( XmlNode *pNode )
 {
-        lChildren.append( pNode );
-        lPostContent.append( NULL );
-        nCurContent++;
+        Child c = { typeNode };
+        c.pNode = pNode;
+        lChildren.append( c );
         pNode->pParent = this;
 
         return pNode;
@@ -142,21 +104,16 @@ XmlNode *XmlNode::getParent()
         return pParent;
 }
 
-void XmlNode::addProperty( const char *sName, const char *sValue )
+void XmlNode::addProperty( const Bu::FString &sName, const Bu::FString &sValue )
 {
-        std::string *pName = new std::string( sName );
-        std::string *pValue = new std::string( sValue );
-        
-        hProperties.insert( pName->c_str(), pValue->c_str() );
-        lPropNames.append( pName );
-        lPropValues.append( pValue );
+        hProperties.insert( sName, sValue );
 }
 
 int XmlNode::getNumProperties()
 {
-        return lPropNames.getSize();
+        return hProperties.size();
 }
-
+/*
 const char *XmlNode::getPropertyName( int nIndex )
 {
         std::string *tmp = ((std::string *)lPropNames[nIndex]);
@@ -172,15 +129,12 @@ const char *XmlNode::getProperty( int nIndex )
                 return NULL;
         return tmp->c_str();
 }
-
-const char *XmlNode::getProperty( const char *sName )
+*/
+Bu::FString XmlNode::getProperty( const Bu::FString &sName )
 {
-        const char *tmp = (const char *)hProperties[sName];
-        if( tmp == NULL )
-                return NULL;
-        return tmp;
+        return hProperties[sName];
 }
-
+/*
 void XmlNode::deleteProperty( int nIndex )
 {
         hProperties.del( ((std::string *)lPropNames[nIndex])->c_str() );
@@ -194,29 +148,33 @@ void XmlNode::deleteProperty( int nIndex )
 
 bool XmlNode::hasChildren()
 {
-        return lChildren.getSize()>0;
-}
+        return hChildren.getSize()>0;
+}*/
 
 int XmlNode::getNumChildren()
 {
         return lChildren.getSize();
 }
-
+/*
 XmlNode *XmlNode::getChild( int nIndex )
 {
         return (XmlNode *)lChildren[nIndex];
 }
-
-XmlNode *XmlNode::getChild( const char *sName, int nSkip )
+*/
+XmlNode *XmlNode::getChild( const Bu::FString &sName, int nSkip )
 {
-        return (XmlNode *)hChildren.get( sName, nSkip );
+        if( !hChildren.has( sName ) )
+                return NULL;
+
+        Bu::List<XmlNode *>::iterator i = hChildren[sName]->begin();
+        return *i;
 }
 
-const char *XmlNode::getName()
+Bu::FString XmlNode::getName()
 {
-        return sName.c_str();
+        return sName;
 }
-
+/*
 void XmlNode::deleteNode( int nIndex, const char *sReplacementText )
 {
         XmlNode *xRet = detatchNode( nIndex, sReplacementText );
@@ -442,4 +400,4 @@ void XmlNode::deleteNodeKeepChildren( int nIndex )
 void XmlNode::replaceNodeWithChildren( int nIndex, XmlNode *pNewNode )
 {
 }
-
+*/
diff --git a/src/xmlnode.h b/src/old/xmlnode.h
index 7525306..c895cd8 100644
--- a/src/xmlnode.h
+++ b/src/old/xmlnode.h
@@ -2,8 +2,9 @@
 #define XMLNODE
 
 #include <iostream>
-#include "linkedlist.h"
-#include "hashtable.h"
+#include "bu/list.h"
+#include "bu/hash.h"
+#include "bu/fstring.h"
 
 /**
  * Maintains all data pertient to an XML node, including sub-nodes and content.
@@ -25,9 +26,8 @@ public:
          *@param sContent The initial content string.
          */
         XmlNode(
-                const char *sName=NULL,
-                XmlNode *pParent = NULL,
-                const char *sContent=NULL
+                const Bu::FString &sName,
+                XmlNode *pParent=NULL
                 );
         
         /**
@@ -39,7 +39,7 @@ public:
          * Change the name of the node.
          *@param sName The new name of the node.
          */
-        void setName( const char *sName );
+        //void setName( const char *sName );
 
         /**
          * Construct a new node and add it as a child to this node, also return a
@@ -48,7 +48,7 @@ public:
          *@param sContent The initial content of the new node.
          *@returns A pointer to the newly created child node.
          */
-        XmlNode *addChild( const char *sName, const char *sContent=NULL );
+        XmlNode *addChild( const Bu::FString &sName );
 
         /**
          * Add an already created XmlNode as a child to this node.  The new child
@@ -65,7 +65,7 @@ public:
          * in use will overwrite that property.
          *@param sValue The textual value of the property.
          */
-        void addProperty( const char *sName, const char *sValue );
+        void addProperty( const Bu::FString &sName, const Bu::FString &sValue );
 
         /**
          * Get a pointer to the parent node, if any.
@@ -86,14 +86,6 @@ public:
         int getNumChildren();
 
         /**
-         * Get a child node at a specific index.
-         *@param nIndex The zero-based index of the child to retreive.
-         *@returns A pointer to the child, or NULL if you requested an invalid
-         * index.
-         */
-        XmlNode *getChild( int nIndex );
-
-        /**
          * Get a child with the specified name, and possibly skip value.  For an
          * explination of skip values see the HashTable.
          *@param sName The name of the child to find.
@@ -101,14 +93,14 @@ public:
          *@returns A pointer to the child, or NULL if no child with that name was
          * found.
          */
-        XmlNode *getChild( const char *sName, int nSkip=0 );
+        XmlNode *getChild( const Bu::FString &sName, int nSkip=0 );
 
         /**
          * Get a pointer to the name of this node.  Do not change this, use setName
          * instead.
          *@returns A pointer to the name of this node.
          */
-        const char *getName();
+        Bu::FString getName();
 
         /**
          * Set the content of this node, optionally at a specific index.  Using the
@@ -116,14 +108,7 @@ public:
          *@param sContent The content string to use.
          *@param nIndex The index of the content.
          */
-        void setContent( const char *sContent, int nIndex=-1 );
-
-        /**
-         * Get the content string at a given index, or zero for initial content.
-         *@param nIndex The index of the content.
-         *@returns A pointer to the content at that location.
-         */
-        const char *getContent( int nIndex = 0 );
+        //void setContent( const char *sContent, int nIndex=-1 );
 
         /**
          * Get the number of properties in this node.
@@ -132,36 +117,12 @@ public:
         int getNumProperties();
 
         /**
-         * Get a property's name by index.
-         *@param nIndex The index of the property to examine.
-         *@returns A pointer to the name of the property specified, or NULL if none
-         * found.
-         */
-        const char *getPropertyName( int nIndex );
-
-        /**
-         * Get a proprty's value by index.
-         *@param nIndex The index of the property to examine.
-         *@returns A pointer to the value of the property specified, or NULL if none
-         * found.
-         */
-        const char *getProperty( int nIndex );
-
-        /**
          * Get a propery's value by name.
          *@param sName The name of the property to examine.
          *@returns A pointer to the value of the property specified, or NULL if none
          * found.
          */
-        const char *getProperty( const char *sName );
-
-        /**
-         * Delete a property by index.
-         *@param nIndex The index of the property to delete.
-         *@returns True if the property was found and deleted, false if it wasn't
-         * found.
-         */
-        void deleteProperty( int nIndex );
+        Bu::FString getProperty( const Bu::FString &sName );
 
         /**
          * Delete a child node, possibly replacing it with some text.  This actually
@@ -171,7 +132,7 @@ public:
          *@returns True of the node was found, and deleted, false if it wasn't
          * found.
          */
-        void deleteNode( int nIndex, const char *sReplacementText = NULL );
+        //void deleteNode( int nIndex, const char *sReplacementText = NULL );
 
         /**
          * Delete a given node, but move all of it's children and content up to
@@ -180,7 +141,7 @@ public:
          *@param nIndex The node to delete.
          *@returns True if the node was found and deleted, false if it wasn't.
          */
-        void deleteNodeKeepChildren( int nIndex );
+        //void deleteNodeKeepChildren( int nIndex );
 
         /**
          * Detatch a given child node from this node.  This effectively works just
@@ -192,7 +153,7 @@ public:
          *@returns A pointer to the newly detatched node, which then passes
          * ownership to the caller.
          */
-        XmlNode *detatchNode( int nIndex, const char *sReplacementText = NULL );
+        //XmlNode *detatchNode( int nIndex, const char *sReplacementText = NULL );
 
         /**
          * Replace a given node with a different node that is not currently owned by
@@ -201,7 +162,7 @@ public:
          *@param pNewNode The new node to replace the old node with.
          *@returns True if the node was found and replaced, false if it wasn't.
          */
-        void replaceNode( int nIndex, XmlNode *pNewNode );
+        //void replaceNode( int nIndex, XmlNode *pNewNode );
 
         /**
          * Replace a given node with the children and content of a given node.
@@ -210,24 +171,34 @@ public:
          * replace the node specified by nIndex.
          *@returns True if the node was found and replaced, false if it wasn't.
          */
-        void replaceNodeWithChildren( int nIndex, XmlNode *pNewNode );
+        //void replaceNodeWithChildren( int nIndex, XmlNode *pNewNode );
 
         /**
          * Get a copy of this node and all children.  getCopy is recursive, so
          * beware copying large trees of xml.
          *@returns A newly created copy of this node and all of it's children.
          */
-        XmlNode *getCopy();
+        //XmlNode *getCopy();
+        
+        enum ChildType
+        {
+                typeNode,
+                typeContent
+        };
 
 private:
-        std::string sName;      /**< The name of the node. */
-        std::string *sPreContent;       /**< The content that goes before any node. */
-        LinkedList lChildren;   /**< The children. */
-        LinkedList lPostContent;        /**< The content that comes after children. */
-        HashTable hProperties;  /**< Property hashtable. */
-        HashTable hChildren;    /**< Children hashtable. */
-        LinkedList lPropNames;  /**< List of property names. */
-        LinkedList lPropValues; /**< List of property values. */
+        typedef struct
+        {
+                uint8_t nType;
+                union {
+                        XmlNode *pNode;
+                        Bu::FString *pContent;
+                };
+        } Child;
+        Bu::FString sName;      /**< The name of the node. */
+        Bu::List<Child> lChildren;      /**< The children. */
+        Bu::Hash<Bu::FString, Bu::FString> hProperties; /**< Property hashtable. */
+        Bu::Hash<Bu::FString, Bu::List<XmlNode *> > hChildren;  /**< Children hashtable. */
         XmlNode *pParent;       /**< A pointer to the parent of this node. */
         int nCurContent;        /**< The current content we're on, for using the -1 on
                                                          setContent. */
diff --git a/src/xmlreader.cpp b/src/old/xmlreader.cpp
index 18df69c..38cad5f 100644
--- a/src/xmlreader.cpp
+++ b/src/old/xmlreader.cpp
@@ -1,32 +1,49 @@
-#include "xmlreader.h"
-#include "exceptions.h"
+#include "bu/xmlreader.h"
+#include "bu/exceptions.h"
 #include <string.h>
-#include "hashfunctionstring.h"
 
-XmlReader::XmlReader( bool bStrip ) :
-        bStrip( bStrip ),
-        htEntity( new HashFunctionString(), 11 )
+XmlReader::XmlReader( Bu::Stream &sIn, bool bStrip ) :
+        sIn( sIn ),
+        bStrip( bStrip )
 {
+        buildDoc();
 }
 
 XmlReader::~XmlReader()
 {
-        void *i = htEntity.getFirstItemPos();
-        while( (i = htEntity.getNextItemPos( i ) ) )
+}
+
+char XmlReader::getChar( int nIndex )
+{
+        if( sBuf.getSize() <= nIndex )
         {
-                free( (char *)(htEntity.getItemID( i )) );
-                delete (StaticString *)htEntity.getItemData( i );
+                int nInc = nIndex-sBuf.getSize()+1;
+                char *buf = new char[nInc];
+                sIn.read( buf, nInc );
+                sBuf.append( buf, nInc );
+                delete[] buf;
         }
+
+        return sBuf[nIndex];
 }
 
-void XmlReader::addEntity( const char *name, const char *value )
+void XmlReader::usedChar( int nAmnt )
 {
-        if( htEntity[name] ) return;
-
-        char *sName = strdup( name );
-        StaticString *sValue = new StaticString( value );
+        if( nAmnt >= sBuf.getSize() )
+        {
+                sBuf.clear();
+        }
+        else
+        {
+                char *s = sBuf.getStr();
+                memcpy( s, s+nAmnt, sBuf.getSize()-nAmnt );
+                sBuf.resize( sBuf.getSize()-nAmnt );
+        }
+}
 
-        htEntity.insert( sName, sValue );
+void XmlReader::addEntity( const Bu::FString &name, const Bu::FString &value )
+{
+        htEntity[name] = value;
 }
 
 #define gcall( x ) if( x == false ) return false;
@@ -99,7 +116,7 @@ void XmlReader::entity()
                 {
                         usedChar( 2 );
                         ws();
-                        std::string buf;
+                        Bu::FString buf;
                         for(;;)
                         {
                                 char chr = getChar();
@@ -111,7 +128,7 @@ void XmlReader::entity()
                         if( strcmp( buf.c_str(), "ENTITY") == 0 )
                         {
                                 ws();
-                                std::string name;
+                                Bu::FString name;
                                 for(;;)
                                 {
                                         char chr = getChar();
@@ -124,21 +141,19 @@ void XmlReader::entity()
                                 usedChar();
                                 if( quot != '\'' && quot != '\"' )
                                 {
-                                        throw XmlException(
+                                        throw Bu::XmlException(
                                                 "Only quoted entity values are supported."
                                                 );
                                 }
-                                std::string value;
+                                Bu::FString value;
                                 for(;;)
                                 {
                                         char chr = getChar();
                                         usedChar();
                                         if( chr == '&' )
                                         {
-                                                StaticString *tmp = getEscape();
-                                                if( tmp == NULL ) throw XmlException("Entity thing");
-                                                value += tmp->getString();
-                                                delete tmp;
+                                                Bu::FString tmp = getEscape();
+                                                value += tmp;
                                         }
                                         else if( chr == quot )
                                         {
@@ -158,7 +173,7 @@ void XmlReader::entity()
                                 }
                                 else
                                 {
-                                        throw XmlException(
+                                        throw Bu::XmlException(
                                                 "Malformed ENTITY:  unexpected '%c' found.",
                                                 getChar()
                                                 );
@@ -166,7 +181,7 @@ void XmlReader::entity()
                         }
                         else
                         {
-                                throw XmlException(
+                                throw Bu::XmlException(
                                         "Unsupported header symbol: %s",
                                         buf.c_str()
                                         );
@@ -203,12 +218,12 @@ bool XmlReader::node()
                 }
                 else
                 {
-                        throw XmlException("Close node in singleNode malformed!");
+                        throw Bu::XmlException("Close node in singleNode malformed!");
                 }
         }
         else
         {
-                throw XmlException("Close node expected, but not found.");
+                throw Bu::XmlException("Close node expected, but not found.");
                 return false;
         }
 
@@ -224,7 +239,7 @@ bool XmlReader::startNode()
                 if( getChar() == '/' )
                 {
                         // Heh, it's actually a close node, go figure
-                        FlexBuf fbName;
+                        Bu::FString sName;
                         usedChar();
                         gcall( ws() );
 
@@ -235,19 +250,19 @@ bool XmlReader::startNode()
                                 {
                                         // Here we actually compare the name we got to the name
                                         // we already set, they have to match exactly.
-                                        if( !strcasecmp( getCurrent()->getName(), fbName.getData() ) )
+                                        if( getCurrent()->getName() == sName )
                                         {
                                                 closeNode();
                                                 break;
                                         }
                                         else
                                         {
-                                                throw XmlException("Got a mismatched node close tag.");
+                                                throw Bu::XmlException("Got a mismatched node close tag.");
                                         }
                                 }
                                 else
                                 {
-                                        fbName.appendData( chr );
+                                        sName += chr;
                                         usedChar();
                                 }
                         }
@@ -260,13 +275,13 @@ bool XmlReader::startNode()
                         }
                         else
                         {
-                                throw XmlException("Got extra junk data instead of node close tag.");
+                                throw Bu::XmlException("Got extra junk data instead of node close tag.");
                         }
                 }
                 else
                 {
                         // We're good, format is consistant
-                        addNode();
+                        //addNode();
 
                         // Skip extra whitespace
                         gcall( ws() );
@@ -278,7 +293,7 @@ bool XmlReader::startNode()
         }
         else
         {
-                throw XmlException("Expected to find node opening char, '<'.");
+                throw Bu::XmlException("Expected to find node opening char, '<'.");
         }
 
         return true;
@@ -286,19 +301,19 @@ bool XmlReader::startNode()
 
 bool XmlReader::name()
 {
-        FlexBuf fbName;
+        Bu::FString sName;
         
         while( true )
         {
                 char chr = getChar();
                 if( isws( chr ) || chr == '>' || chr == '/' )
                 {
-                        setName( fbName.getData() );
+                        addNode( sName );
                         return true;
                 }
                 else
                 {
-                        fbName.appendData( chr );
+                        sName += chr;
                         usedChar();
                 }
         }
@@ -325,7 +340,7 @@ bool XmlReader::paramlist()
         return true;
 }
 
-StaticString *XmlReader::getEscape()
+Bu::FString XmlReader::getEscape()
 {
         if( getChar( 1 ) == '#' )
         {
@@ -349,12 +364,12 @@ StaticString *XmlReader::getEscape()
                 buf[0] = (char)strtol( buf, (char **)NULL, base );
                 buf[1] = '\0';
 
-                return new StaticString( buf );
+                return buf;
         }
         else
         {
                 // ...otherwise replace with the appropriate string...
-                std::string buf;
+                Bu::FString buf;
                 usedChar();
                 for(;;)
                 {
@@ -364,18 +379,14 @@ StaticString *XmlReader::getEscape()
                         buf += cbuf;
                 }
 
-                StaticString *tmp = (StaticString *)htEntity[buf.c_str()];
-                if( tmp == NULL ) return NULL;
-
-                StaticString *ret = new StaticString( *tmp );
-                return ret;
+                return htEntity[buf];
         }
 }
 
 bool XmlReader::param()
 {
-        FlexBuf fbName;
-        FlexBuf fbValue;
+        Bu::FString sName;
+        Bu::FString sValue;
 
         while( true )
         {
@@ -386,7 +397,7 @@ bool XmlReader::param()
                 }
                 else
                 {
-                        fbName.appendData( chr );
+                        sName.append( chr );
                         usedChar();
                 }
         }
@@ -411,21 +422,18 @@ bool XmlReader::param()
                                 if( chr == '"' )
                                 {
                                         usedChar();
-                                        addProperty( fbName.getData(), fbValue.getData() );
+                                        addProperty( sName.getStr(), sValue.getStr() );
                                         return true;
                                 }
                                 else
                                 {
                                         if( chr == '&' )
                                         {
-                                                StaticString *tmp = getEscape();
-                                                if( tmp == NULL ) return false;
-                                                fbValue.appendData( tmp->getString() );
-                                                delete tmp;
+                                                sValue += getEscape();
                                         }
                                         else
                                         {
-                                                fbValue.appendData( chr );
+                                                sValue += chr;
                                                 usedChar();
                                         }
                                 }
@@ -439,21 +447,18 @@ bool XmlReader::param()
                                 chr = getChar();
                                 if( isws( chr ) || chr == '/' || chr == '>' )
                                 {
-                                        addProperty( fbName.getData(), fbValue.getData() );
+                                        addProperty( sName.getStr(), sValue.getStr() );
                                         return true;
                                 }
                                 else
                                 {
                                         if( chr == '&' )
                                         {
-                                                StaticString *tmp = getEscape();
-                                                if( tmp == NULL ) return false;
-                                                fbValue.appendData( tmp->getString() );
-                                                delete tmp;
+                                                sValue += getEscape();
                                         }
                                         else
                                         {
-                                                fbValue.appendData( chr );
+                                                sValue += chr;
                                                 usedChar();
                                         }
                                 }
@@ -462,7 +467,7 @@ bool XmlReader::param()
         }
         else
         {
-                throw XmlException("Expected an equals to seperate the params.");
+                throw Bu::XmlException("Expected an equals to seperate the params.");
                 return false;
         }
 
@@ -471,7 +476,7 @@ bool XmlReader::param()
 
 bool XmlReader::content()
 {
-        FlexBuf fbContent;
+        Bu::FString sContent;
 
         if( bStrip ) gcall( ws() );
 
@@ -482,37 +487,37 @@ bool XmlReader::content()
                 {
                         if( getChar(1) == '/' )
                         {
-                                if( fbContent.getLength() > 0 )
+                                if( sContent.getSize() > 0 )
                                 {
                                         if( bStrip )
                                         {
                                                 int j;
-                                                for( j = fbContent.getLength()-1; isws(fbContent.getData()[j]); j-- );
-                                                ((char *)fbContent.getData())[j+1] = '\0';
+                                                for( j = sContent.getSize()-1; isws(sContent[j]); j-- );
+                                                sContent[j+1] = '\0';
                                         }
-                                        setContent( fbContent.getData() );
+                                        setContent( sContent.getStr() );
                                 }
                                 usedChar( 2 );
                                 gcall( ws() );
-                                FlexBuf fbName;
+                                Bu::FString sName;
                                 while( true )
                                 {
                                         chr = getChar();
                                         if( isws( chr ) || chr == '>' )
                                         {
-                                                if( !strcasecmp( getCurrent()->getName(), fbName.getData() ) )
+                                                if( !strcasecmp( getCurrent()->getName().getStr(), sName.getStr() ) )
                                                 {
                                                         closeNode();
                                                         break;
                                                 }
                                                 else
                                                 {
-                                                        throw XmlException("Mismatched close tag found: <%s> to <%s>.", getCurrent()->getName(), fbName.getData() );
+                                                        throw Bu::XmlException("Mismatched close tag found: <%s> to <%s>.", getCurrent()->getName().getStr(), sName.getStr() );
                                                 }
                                         }
                                         else
                                         {
-                                                fbName.appendData( chr );
+                                                sName += chr;
                                                 usedChar();
                                         }
                                 }
@@ -524,7 +529,7 @@ bool XmlReader::content()
                                 }
                                 else
                                 {
-                                        throw XmlException("Malformed close tag.");
+                                        throw Bu::XmlException("Malformed close tag.");
                                 }
                         }
                         else if( getChar(1) == '!' )
@@ -534,7 +539,7 @@ bool XmlReader::content()
                                         getChar(3) != '-' )
                                 {
                                         // Not a valid XML comment
-                                        throw XmlException("Malformed comment start tag found.");
+                                        throw Bu::XmlException("Malformed comment start tag found.");
                                 }
 
                                 usedChar( 4 );
@@ -549,7 +554,7 @@ bool XmlReader::content()
                                                         // The next one has to be a '>' now
                                                         if( getChar( 2 ) != '>' )
                                                         {
-                                                                throw XmlException("Malformed comment close tag found.  You cannot have a '--' that isn't followed by a '>' in a comment.");
+                                                                throw Bu::XmlException("Malformed comment close tag found.  You cannot have a '--' that isn't followed by a '>' in a comment.");
                                                         }
                                                         usedChar( 3 );
                                                         break;
@@ -569,16 +574,16 @@ bool XmlReader::content()
                         }
                         else
                         {
-                                if( fbContent.getLength() > 0 )
+                                if( sContent.getSize() > 0 )
                                 {
                                         if( bStrip )
                                         {
                                                 int j;
-                                                for( j = fbContent.getLength()-1; isws(fbContent.getData()[j]); j-- );
-                                                ((char *)fbContent.getData())[j+1] = '\0';
+                                                for( j = sContent.getSize()-1; isws(sContent[j]); j-- );
+                                                sContent[j+1] = '\0';
                                         }
-                                        setContent( fbContent.getData() );
-                                        fbContent.clearData();
+                                        setContent( sContent.getStr() );
+                                        sContent.clear();
                                 }
                                 gcall( node() );
                         }
@@ -587,14 +592,11 @@ bool XmlReader::content()
                 }
                 else if( chr == '&' )
                 {
-                        StaticString *tmp = getEscape();
-                        if( tmp == NULL ) return false;
-                        fbContent.appendData( tmp->getString() );
-                        delete tmp;
+                        sContent += getEscape();
                 }
                 else
                 {
-                        fbContent.appendData( chr );
+                        sContent += chr;
                         usedChar();
                 }
         }
diff --git a/src/xmlreader.h b/src/old/xmlreader.h
index c8f7202..7c85ddb 100644
--- a/src/xmlreader.h
+++ b/src/old/xmlreader.h
@@ -2,10 +2,10 @@
 #define XMLREADER
 
 #include <stdio.h>
-#include "xmldocument.h"
-#include "flexbuf.h"
-#include "hashtable.h"
-#include "staticstring.h"
+#include "bu/xmldocument.h"
+#include "bu/hash.h"
+#include "bu/fstring.h"
+#include "bu/stream.h"
 
 /**
  * Takes care of reading in xml formatted data from a file.  This could/should
@@ -32,7 +32,7 @@ public:
          * in content, a-la html.
          *@param bStrip Strip out leading and trailing whitespace?
          */
-        XmlReader( bool bStrip=false );
+        XmlReader( Bu::Stream &sIn, bool bStrip=false );
 
         /**
          * Destroy this XmlReader.
@@ -54,12 +54,12 @@ private:
          *@returns A single character at the requested position, or 0 for end of
          * stream.
          */
-        virtual char getChar( int nIndex = 0 ) = 0;
+        virtual char getChar( int nIndex = 0 );
 
         /**
          * Called to increment the current stream position by a single character.
          */
-        virtual void usedChar( int nAmnt = 1) = 0;
+        virtual void usedChar( int nAmnt = 1 );
 
         /**
          * Automoton function: is whitespace.
@@ -108,9 +108,9 @@ private:
          *@param name The name of the entity
          *@param value The value of the entity
          */
-        void addEntity( const char *name, const char *value );
+        void addEntity( const Bu::FString &name, const Bu::FString &value );
 
-        StaticString *getEscape();
+        Bu::FString getEscape();
 
         /**
          * Automoton function: paramlist.  Processes a list of node params.
@@ -130,12 +130,15 @@ private:
          */
         bool content();
         
-        FlexBuf fbContent;              /**< buffer for the current node's content. */
-        FlexBuf fbParamName;    /**< buffer for the current param's name. */
-        FlexBuf fbParamValue;   /**< buffer for the current param's value. */
-        bool bStrip;    /**< Are we stripping whitespace? */
+        Bu::FString sContent;           /**< buffer for the current node's content. */
+        Bu::FString sParamName;         /**< buffer for the current param's name. */
+        Bu::FString sParamValue;        /**< buffer for the current param's value. */
+        Bu::Stream &sIn;
+        bool bStrip;                    /**< Are we stripping whitespace? */
 
-        HashTable htEntity;             /**< Entity type definitions. */
+        Bu::Hash<Bu::FString,Bu::FString> htEntity;             /**< Entity type definitions. */
+
+        Bu::FString sBuf;
 };
 
 #endif
diff --git a/src/xmlstringreader.cpp b/src/old/xmlstringreader.cpp
index 3956ff3..3956ff3 100644
--- a/src/xmlstringreader.cpp
+++ b/src/old/xmlstringreader.cpp
diff --git a/src/xmlstringreader.h b/src/old/xmlstringreader.h
index 1239ef4..1239ef4 100644
--- a/src/xmlstringreader.h
+++ b/src/old/xmlstringreader.h
diff --git a/src/xmlstringwriter.cpp b/src/old/xmlstringwriter.cpp
index adeed6a..adeed6a 100644
--- a/src/xmlstringwriter.cpp
+++ b/src/old/xmlstringwriter.cpp
diff --git a/src/xmlstringwriter.h b/src/old/xmlstringwriter.h
index 0d567b9..0d567b9 100644
--- a/src/xmlstringwriter.h
+++ b/src/old/xmlstringwriter.h
diff --git a/src/xmlwriter.cpp b/src/old/xmlwriter.cpp
index 56880b6..7dc6ca9 100644
--- a/src/xmlwriter.cpp
+++ b/src/old/xmlwriter.cpp
@@ -2,17 +2,10 @@
 #include <stdlib.h>
 #include "xmlwriter.h"
 
-XmlWriter::XmlWriter( const char *sIndent, XmlNode *pRoot ) :
-        XmlDocument( pRoot )
+XmlWriter::XmlWriter( const Bu::FString &sIndent, XmlNode *pRoot ) :
+        XmlDocument( pRoot ),
+        sIndent( sIndent )
 {
-        if( sIndent == NULL )
-        {
-                this->sIndent = "";
-        }
-        else
-        {
-                this->sIndent = sIndent;
-        }
 }
 
 XmlWriter::~XmlWriter()
@@ -24,7 +17,7 @@ void XmlWriter::write()
         write( getRoot(), sIndent.c_str() );
 }
 
-void XmlWriter::write( XmlNode *pRoot, const char *sIndent )
+void XmlWriter::write( XmlNode *pRoot, const Bu::FString &sIndent )
 {
         writeNode( pRoot, 0, sIndent );
 }
@@ -39,7 +32,7 @@ void XmlWriter::closeNode()
         }
 }
 
-void XmlWriter::writeIndent( int nIndent, const char *sIndent )
+void XmlWriter::writeIndent( int nIndent, const Bu::FString &sIndent )
 {
         if( sIndent == NULL ) return;
         for( int j = 0; j < nIndent; j++ )
@@ -48,26 +41,27 @@ void XmlWriter::writeIndent( int nIndent, const char *sIndent )
         }
 }
 
-std::string XmlWriter::escape( std::string sIn )
+Bu::FString XmlWriter::escape( const Bu::FString &sIn )
 {
-        std::string sOut;
+        Bu::FString sOut;
 
-        std::string::const_iterator i;
-        for( i = sIn.begin(); i != sIn.end(); i++ )
+        int nMax = sIn.getSize();
+        for( int j = 0; j < nMax; j++ )
         {
-                if( ((*i >= ' ' && *i <= '9') ||
-                        (*i >= 'a' && *i <= 'z') ||
-                        (*i >= 'A' && *i <= 'Z') ) &&
-                        (*i != '\"' && *i != '\'' && *i != '&')
+                char c = sIn[j];
+                if( ((c >= ' ' && c <= '9') ||
+                        (c >= 'a' && c <= 'z') ||
+                        (c >= 'A' && c <= 'Z') ) &&
+                        (c != '\"' && c != '\'' && c != '&')
                   )
                 {
-                        sOut += *i;
+                        sOut += c;
                 }
                 else
                 {
                         sOut += "&#";
                         char buf[4];
-                        sprintf( buf, "%u", (unsigned char)*i );
+                        sprintf( buf, "%u", (unsigned char)c );
                         sOut += buf;
                         sOut += ';';
                 }
@@ -76,19 +70,19 @@ std::string XmlWriter::escape( std::string sIn )
         return sOut;
 }
 
-void XmlWriter::writeNodeProps( XmlNode *pNode, int nIndent, const char *sIndent )
+void XmlWriter::writeNodeProps( XmlNode *pNode, int nIndent, const Bu::FString &sIndent )
 {
         for( int j = 0; j < pNode->getNumProperties(); j++ )
         {
                 writeString(" ");
-                writeString( pNode->getPropertyName( j ) );
+                //writeString( pNode->getPropertyName( j ) );
                 writeString("=\"");
-                writeString( escape( pNode->getProperty( j ) ).c_str() );
+                //writeString( escape( pNode->getProperty( j ) ).c_str() );
                 writeString("\"");
         }
 }
 
-void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
+void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const Bu::FString &sIndent )
 {
         if( pNode->hasChildren() )
         {
@@ -96,15 +90,15 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                 writeString("<");
                 writeString( pNode->getName() );
                 writeNodeProps( pNode, nIndent, sIndent );
-                if( sIndent )
+                if( sIndent != "" )
                         writeString(">\n");
                 else
                         writeString(">");
-
+/*
                 if( pNode->getContent( 0 ) )
                 {
                         writeIndent( nIndent+1, sIndent );
-                        if( sIndent )
+                        if( sIndent != "" )
                         {
                                 writeString( pNode->getContent( 0 ) );
                                 writeString("\n");
@@ -129,9 +123,9 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                                         writeString( pNode->getContent( j+1 ) );
                         }
                 }
-                
+*/              
                 writeIndent( nIndent, sIndent );
-                if( sIndent )
+                if( sIndent != "" )
                 {
                         writeString("</");
                         writeString( pNode->getName() );
@@ -143,7 +137,7 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                         writeString( pNode->getName() );
                         writeString(">");
                 }
-        }
+        }/*
         else if( pNode->getContent() )
         {
                 writeIndent( nIndent, sIndent );
@@ -157,14 +151,14 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                 writeString(">");
                 if( sIndent )
                         writeString("\n");
-        }
+        }*/
         else
         {
                 writeIndent( nIndent, sIndent );
                 writeString("<");
                 writeString( pNode->getName() );
                 writeNodeProps( pNode, nIndent, sIndent );
-                if( sIndent )
+                if( sIndent != "" )
                         writeString("/>\n");
                 else
                         writeString("/>");
diff --git a/src/xmlwriter.h b/src/old/xmlwriter.h
index c48e810..7e3c876 100644
--- a/src/xmlwriter.h
+++ b/src/old/xmlwriter.h
@@ -31,7 +31,7 @@ public:
          * this to a tab or some spaces it will never effect the content of your
          * file.
          */
-        XmlWriter( const char *sIndent=NULL, XmlNode *pRoot=NULL );
+        XmlWriter( const Bu::FString &sIndent="", XmlNode *pRoot=NULL );
 
         /**
          * Destroy the writer.
@@ -49,16 +49,16 @@ public:
         void write();
 
 private:
-        std::string sIndent;    /**< The indent string */
+        Bu::FString sIndent;    /**< The indent string */
 
-        std::string escape( std::string sIn );
+        Bu::FString escape( const Bu::FString &sIn );
         
         /**
          * Write the file.
          *@param pNode The root node
          *@param sIndent The indent text.
          */
-        void write( XmlNode *pNode, const char *sIndent=NULL );
+        void write( XmlNode *pNode, const Bu::FString &sIndent );
 
         /**
          * Write a node in the file, including children.
@@ -66,7 +66,7 @@ private:
          *@param nIndent The indent level (the number of times to include sIndent)
          *@param sIndent The indent text.
          */
-        void writeNode( XmlNode *pNode, int nIndent, const char *sIndent );
+        void writeNode( XmlNode *pNode, int nIndent, const Bu::FString &sIndent );
 
         /**
          * Write the properties of a node.
@@ -74,14 +74,14 @@ private:
          *@param nIndent The indent level of the containing node
          *@param sIndent The indent text.
          */
-        void writeNodeProps( XmlNode *pNode, int nIndent, const char *sIndent );
+        void writeNodeProps( XmlNode *pNode, int nIndent, const Bu::FString &sIndent );
 
         /**
          * Called to write the actual indent.
          *@param nIndent The indent level.
          *@param sIndent The indent text.
          */
-        void writeIndent( int nIndent, const char *sIndent );
+        void writeIndent( int nIndent, const Bu::FString &sIndent );
 
         /**
          * This is the function that must be overridden in order to use this class.
@@ -90,7 +90,7 @@ private:
          * will break the XML formatting.
          *@param sString The string data to write to the output.
          */
-        virtual void writeString( const char *sString ) = 0;
+        virtual void writeString( const Bu::FString &sString ) = 0;
 };
 
 #endif