3 files changed, 220 insertions, 14 deletions

diff --git a/src/unit/xml.cpp b/src/unit/xml.cpp
index 559b2f4..e4d779c 100644
--- a/src/unit/xml.cpp
+++ b/src/unit/xml.cpp
@@ -15,6 +15,10 @@ public:
                 TEST_ADD( XmlCoreTestSuite::badXml01 )
                 TEST_ADD( XmlCoreTestSuite::badXml02 )
                 TEST_ADD( XmlCoreTestSuite::badXml03 )
+
+                TEST_ADD( XmlCoreTestSuite::entityBuiltin01 )
+
+                TEST_ADD( XmlCoreTestSuite::entityDoc01 )
         }
         
 private:
@@ -32,6 +36,18 @@ private:
         {
                 TEST_THROWS( XmlStringReader r("<hello param=\"stuff?"), XmlException & );
         }
+
+        void entityBuiltin01()
+        {
+                XmlStringReader r("<hello>&gt;&lt;&amp;&apos;&quot;</hello>");
+                TEST_ASSERT( strcmp( r.getRoot()->getContent(), "><&\'\"" ) == 0 );
+        }
+        
+        void entityDoc01()
+        {
+                XmlStringReader r("<!ENTITY  name  \"bob the man\"><hello>&quot;&name;&quot;</hello>");
+                TEST_ASSERT( strcmp( r.getRoot()->getContent(), "\"bob the man\"" ) == 0 );
+        }
 };
 
 int main( int argc, char *argv[] )
diff --git a/src/xmlreader.cpp b/src/xmlreader.cpp
index 70fd1d7..2a5f63f 100644
--- a/src/xmlreader.cpp
+++ b/src/xmlreader.cpp
@@ -1,14 +1,32 @@
 #include "xmlreader.h"
 #include "xmlexception.h"
 #include <string.h>
+#include "hashfunctionstring.h"
 
 XmlReader::XmlReader( bool bStrip ) :
-        bStrip( bStrip )
+        bStrip( bStrip ),
+        htEntity( new HashFunctionString(), 11 )
 {
 }
 
 XmlReader::~XmlReader()
 {
+        void *i = htEntity.getFirstItemPos();
+        while( (i = htEntity.getNextItemPos( i ) ) )
+        {
+                free( (char *)(htEntity.getItemID( i )) );
+                delete (StaticString *)htEntity.getItemData( i );
+        }
+}
+
+void XmlReader::addEntity( const char *name, const char *value )
+{
+        if( htEntity[name] ) return;
+
+        char *sName = strdup( name );
+        StaticString *sValue = new StaticString( value );
+
+        htEntity.insert( sName, sValue );
 }
 
 #define gcall( x ) if( x == false ) return false;
@@ -39,11 +57,129 @@ bool XmlReader::buildDoc()
 {
         // take care of initial whitespace
         gcall( ws() );
+        textDecl();
+        entity();
+        addEntity("gt", ">");
+        addEntity("lt", "<");
+        addEntity("amp", "&");
+        addEntity("apos", "\'");
+        addEntity("quot", "\"");
         gcall( node() );
 
         return true;
 }
 
+void XmlReader::textDecl()
+{
+        char chr;
+        if( getChar() == '<' && getChar( 1 ) == '?' )
+        {
+                usedChar( 2 );
+                for(;;)
+                {
+                        if( getChar() == '?' )
+                        {
+                                if( getChar( 1 ) == '>' )
+                                {
+                                        usedChar( 2 );
+                                        return;
+                                }
+                        }
+                        usedChar();
+                }
+        }
+}
+
+void XmlReader::entity()
+{
+        for(;;)
+        {
+                ws();
+
+                if( getChar() == '<' && getChar( 1 ) == '!' )
+                {
+                        usedChar( 2 );
+                        ws();
+                        std::string buf;
+                        for(;;)
+                        {
+                                char chr = getChar();
+                                usedChar();
+                                if( isws( chr ) ) break;
+                                buf += chr;
+                        }
+
+                        if( strcmp( buf.c_str(), "ENTITY") == 0 )
+                        {
+                                ws();
+                                std::string name;
+                                for(;;)
+                                {
+                                        char chr = getChar();
+                                        usedChar();
+                                        if( isws( chr ) ) break;
+                                        name += chr;
+                                }
+                                ws();
+                                char quot = getChar();
+                                usedChar();
+                                if( quot != '\'' && quot != '\"' )
+                                {
+                                        throw XmlException(
+                                                "Only quoted entity values are supported."
+                                                );
+                                }
+                                std::string value;
+                                for(;;)
+                                {
+                                        char chr = getChar();
+                                        usedChar();
+                                        if( chr == '&' )
+                                        {
+                                                StaticString *tmp = getEscape();
+                                                if( tmp == NULL ) throw XmlException("Entity thing");
+                                                value += tmp->getString();
+                                                delete tmp;
+                                        }
+                                        else if( chr == quot )
+                                        {
+                                                break;
+                                        }
+                                        else
+                                        {
+                                                value += chr;
+                                        }
+                                }
+                                ws();
+                                if( getChar() == '>' )
+                                {
+                                        usedChar();
+
+                                        addEntity( name.c_str(), value.c_str() );
+                                }
+                                else
+                                {
+                                        throw XmlException(
+                                                "Malformed ENTITY:  unexpected '%c' found.",
+                                                getChar()
+                                                );
+                                }
+                        }
+                        else
+                        {
+                                throw XmlException(
+                                        "Unsupported header symbol: %s",
+                                        buf.c_str()
+                                        );
+                        }
+                }
+                else
+                {
+                        return;
+                }
+        }
+}
+
 bool XmlReader::node()
 {
         gcall( startNode() )
@@ -190,13 +326,18 @@ bool XmlReader::paramlist()
         return true;
 }
 
-char XmlReader::getEscape()
+StaticString *XmlReader::getEscape()
 {
-        // Right now, we just do # escapes...
         if( getChar( 1 ) == '#' )
         {
-                usedChar();
-                usedChar();
+                // If the entity starts with a # it's a character escape code
+                int base = 10;
+                usedChar( 2 );
+                if( getChar() == 'x' )
+                {
+                        base = 16;
+                        usedChar();
+                }
                 char buf[4];
                 int j = 0;
                 for( j = 0; getChar() != ';'; j++ )
@@ -206,11 +347,29 @@ char XmlReader::getEscape()
                 }
                 usedChar();
                 buf[j] = '\0';
-                return (char)atoi( buf );
+                buf[0] = (char)strtol( buf, (char **)NULL, base );
+                buf[1] = '\0';
+
+                return new StaticString( buf );
         }
         else
         {
-                return '\0';
+                // ...otherwise replace with the appropriate string...
+                std::string buf;
+                usedChar();
+                for(;;)
+                {
+                        char cbuf = getChar();
+                        usedChar();
+                        if( cbuf == ';' ) break;
+                        buf += cbuf;
+                }
+
+                StaticString *tmp = (StaticString *)htEntity[buf.c_str()];
+                if( tmp == NULL ) return NULL;
+
+                StaticString *ret = new StaticString( *tmp );
+                return ret;
         }
 }
 
@@ -260,9 +419,10 @@ bool XmlReader::param()
                                 {
                                         if( chr == '&' )
                                         {
-                                                chr = getEscape();
-                                                if( chr == '\0' ) return false;
-                                                fbValue.appendData( chr );
+                                                StaticString *tmp = getEscape();
+                                                if( tmp == NULL ) return false;
+                                                fbValue.appendData( tmp->getString() );
+                                                delete tmp;
                                         }
                                         else
                                         {
@@ -287,9 +447,10 @@ bool XmlReader::param()
                                 {
                                         if( chr == '&' )
                                         {
-                                                chr = getEscape();
-                                                if( chr == '\0' ) return false;
-                                                fbValue.appendData( chr );
+                                                StaticString *tmp = getEscape();
+                                                if( tmp == NULL ) return false;
+                                                fbValue.appendData( tmp->getString() );
+                                                delete tmp;
                                         }
                                         else
                                         {
@@ -425,6 +586,13 @@ bool XmlReader::content()
 
                         if( bStrip ) gcall( ws() );
                 }
+                else if( chr == '&' )
+                {
+                        StaticString *tmp = getEscape();
+                        if( tmp == NULL ) return false;
+                        fbContent.appendData( tmp->getString() );
+                        delete tmp;
+                }
                 else
                 {
                         fbContent.appendData( chr );
diff --git a/src/xmlreader.h b/src/xmlreader.h
index 4117dfd..a9881cb 100644
--- a/src/xmlreader.h
+++ b/src/xmlreader.h
@@ -4,6 +4,8 @@
 #include <stdio.h>
 #include "xmldocument.h"
 #include "flexbuf.h"
+#include "hashtable.h"
+#include "staticstring.h"
 
 /**
  * Takes care of reading in xml formatted data from a file.  This could/should
@@ -90,7 +92,25 @@ private:
          */
         bool name();
 
-        char getEscape();
+        /**
+         * Automoton function: textDecl.  Processes the xml text decleration, if
+         * there is one.
+         */
+        void textDecl();
+
+        /**
+         * Automoton function: entity.  Processes an entity from the header.
+         */
+        void entity();
+
+        /**
+         * Adds an entity to the list, if it doesn't already exist.
+         *@param name The name of the entity
+         *@param value The value of the entity
+         */
+        void addEntity( const char *name, const char *value );
+
+        StaticString *getEscape();
 
         /**
          * Automoton function: paramlist.  Processes a list of node params.
@@ -114,6 +134,8 @@ private:
         FlexBuf fbParamName;    /**< buffer for the current param's name. */
         FlexBuf fbParamValue;   /**< buffer for the current param's value. */
         bool bStrip;    /**< Are we stripping whitespace? */
+
+        HashTable htEntity;             /**< Entity type definitions. */
 };
 
 #endif