Changeset 738 for code/branches/FICN/src/tinyxml

Timestamp:

Dec 31, 2007, 12:06:33 AM (17 years ago)

Author:

landauf

Message:

updated to the newest tinyXML library and changed one line in the LevelLoader

Location:

code/branches/FICN/src/tinyxml

Files:

• tinystr.cc (modified) (2 diffs)
• tinystr.h (modified) (5 diffs)
• tinyxml.cc (modified) (60 diffs)
• tinyxml.h (modified) (69 diffs)
• tinyxmlerror.cc (modified) (2 diffs)
• tinyxmlparser.cc (modified) (56 diffs)

code/branches/FICN/src/tinyxml/tinystr.cc

@@ -24 +24 @@
 
 /*
- * THIS FILE WAS ALTERED BY Tyge L�vset, 7. April 2005.
+ * THIS FILE WAS ALTERED BY Tyge Løvset, 7. April 2005.
  */
 
@@ -33 +33 @@
 
 // Error value for find primitive
-const TiXmlString::size_type TiXmlString::npos = static_cast< size_type >(-1);
+const TiXmlString::size_type TiXmlString::npos = static_cast< TiXmlString::size_type >(-1);
+
 
 // Null rep.
-//FIXME: missing braces around initializer for ‘char [1]’
-TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, '\0' };
+TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, { '\0' } };
 
 

code/branches/FICN/src/tinyxml/tinystr.h

@@ -43 +43 @@
 #include <string.h>
 
+/*      The support for explicit isn't that universal, and it isn't really
+        required - it is used to check that the TiXmlString class isn't incorrectly
+        used. Be nice to old compilers and macro it here:
+*/
+#if defined(_MSC_VER) && (_MSC_VER >= 1200 )
+        // Microsoft visual studio, version 6 and higher.
+        #define TIXML_EXPLICIT explicit
+#elif defined(__GNUC__) && (__GNUC__ >= 3 )
+        // GCC version 3 and higher.s
+        #define TIXML_EXPLICIT explicit
+#else
+        #define TIXML_EXPLICIT
+#endif
+
+
 /*
    TiXmlString is an emulation of a subset of the std::string template.
@@ -54 +69 @@
   public :
         // The size type used
-        typedef unsigned int size_type;
+        typedef size_t size_type;
 
         // Error value for find primitive
@@ -66 +81 @@
 
         // TiXmlString copy constructor
-        TiXmlString (const TiXmlString & copy)
+        TiXmlString ( const TiXmlString & copy) : rep_(0)
         {
                 init(copy.length());
@@ -73 +88 @@
 
         // TiXmlString constructor, based on a string
-        TiXmlString (const char * copy)
+        TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0)
         {
                 init( static_cast<size_type>( strlen(copy) ));
@@ -80 +95 @@
 
         // TiXmlString constructor, based on a string
-        TiXmlString (const char * str, size_type len)
+        TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0)
         {
                 init(len);

code/branches/FICN/src/tinyxml/tinyxml.cc

@@ -1 +1 @@
 /*
 www.sourceforge.net/projects/tinyxml
-Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
+Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)
 
 This software is provided 'as-is', without any express or implied
@@ -24 +24 @@
 
 #include <ctype.h>
-#include "tinyxml.h"
 
 #ifdef TIXML_USE_STL
 #include <sstream>
+#include <iostream>
 #endif
 
+#include "tinyxml.h"
+
 
 bool TiXmlBase::condenseWhiteSpace = true;
 
-void TiXmlBase::PutString( const TIXML_STRING& str, TIXML_OSTREAM* stream )
-{
-        TIXML_STRING buffer;
-        PutString( str, &buffer );
-        (*stream) << buffer;
-}
-
-void TiXmlBase::PutString( const TIXML_STRING& str, TIXML_STRING* outString )
+// Microsoft compiler security
+FILE* TiXmlFOpen( const char* filename, const char* mode )
+{
+        #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
+                FILE* fp = 0;
+                errno_t err = fopen_s( &fp, filename, mode );
+                if ( !err && fp )
+                        return fp;
+                return 0;
+        #else
+                return fopen( filename, mode );
+        #endif
+}
+
+void TiXmlBase::EncodeString( const TIXML_STRING& str, TIXML_STRING* outString )
 {
         int i=0;
@@ -48 +57 @@
                 unsigned char c = (unsigned char) str[i];
 
-                if (    c == '&' 
+                if (    c == '&'
                      && i < ( (int)str.length() - 2 )
                          && str[i+1] == '#'
@@ -101 +110 @@
                         // Below 32 is symbolic.
                         char buf[ 32 ];
-                        
-                        #if defined(TIXML_SNPRINTF)             
+
+                        #if defined(TIXML_SNPRINTF)
                                 TIXML_SNPRINTF( buf, sizeof(buf), "&#x%02X;", (unsigned) ( c & 0xff ) );
                         #else
                                 sprintf( buf, "&#x%02X;", (unsigned) ( c & 0xff ) );
-                        #endif          
+                        #endif
 
                         //*ME:  warning C4267: convert 'size_t' to 'int'
@@ -122 +131 @@
         }
 }
-
-
-// <-- Strange class for a bug fix. Search for STL_STRING_BUG
-TiXmlBase::StringToBuffer::StringToBuffer( const TIXML_STRING& str )
-{
-        buffer = new char[ str.length()+1 ];
-        if ( buffer )
-        {
-                strcpy( buffer, str.c_str() );
-        }
-}
-
-
-TiXmlBase::StringToBuffer::~StringToBuffer()
-{
-        delete [] buffer;
-}
-// End strange bug fix. -->
 
 
@@ -163 +154 @@
                 node = node->next;
                 delete temp;
-        }       
+        }
 }
 
@@ -170 +161 @@
 {
         target->SetValue (value.c_str() );
-        target->userData = userData; 
+        target->userData = userData;
 }
 
@@ -184 +175 @@
                 node = node->next;
                 delete temp;
-        }       
+        }
 
         firstChild = 0;
@@ -193 +184 @@
 TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node )
 {
+        assert( node->parent == 0 || node->parent == this );
+        assert( node->GetDocument() == 0 || node->GetDocument() == this->GetDocument() );
+
+        if ( node->Type() == TiXmlNode::DOCUMENT )
+        {
+                delete node;
+                if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
+                return 0;
+        }
+
         node->parent = this;
 
@@ -210 +211 @@
 TiXmlNode* TiXmlNode::InsertEndChild( const TiXmlNode& addThis )
 {
+        if ( addThis.Type() == TiXmlNode::DOCUMENT )
+        {
+                if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
+                return 0;
+        }
         TiXmlNode* node = addThis.Clone();
         if ( !node )
@@ -219 +225 @@
 
 TiXmlNode* TiXmlNode::InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis )
-{       
-        if ( !beforeThis || beforeThis->parent != this )
-                return 0;
+{
+        if ( !beforeThis || beforeThis->parent != this ) {
+                return 0;
+        }
+        if ( addThis.Type() == TiXmlNode::DOCUMENT )
+        {
+                if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
+                return 0;
+        }
 
         TiXmlNode* node = addThis.Clone();
@@ -246 +258 @@
 TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis )
 {
-        if ( !afterThis || afterThis->parent != this )
-                return 0;
+        if ( !afterThis || afterThis->parent != this ) {
+                return 0;
+        }
+        if ( addThis.Type() == TiXmlNode::DOCUMENT )
+        {
+                if ( GetDocument() ) GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
+                return 0;
+        }
 
         TiXmlNode* node = addThis.Clone();
@@ -301 +319 @@
 {
         if ( removeThis->parent != this )
-        {       
+        {
                 assert( 0 );
                 return false;
@@ -332 +350 @@
 
 
-TiXmlNode* TiXmlNode::FirstChild( const char * _value )
-{
-        TiXmlNode* node;
-        for ( node = firstChild; node; node = node->next )
+const TiXmlNode* TiXmlNode::LastChild( const char * _value ) const
+{
+        const TiXmlNode* node;
+        for ( node = lastChild; node; node = node->prev )
         {
                 if ( strcmp( node->Value(), _value ) == 0 )
@@ -344 +362 @@
 
 
-const TiXmlNode* TiXmlNode::LastChild( const char * _value ) const
+const TiXmlNode* TiXmlNode::IterateChildren( const TiXmlNode* previous ) const
+{
+        if ( !previous )
+        {
+                return FirstChild();
+        }
+        else
+        {
+                assert( previous->parent == this );
+                return previous->NextSibling();
+        }
+}
+
+
+const TiXmlNode* TiXmlNode::IterateChildren( const char * val, const TiXmlNode* previous ) const
+{
+        if ( !previous )
+        {
+                return FirstChild( val );
+        }
+        else
+        {
+                assert( previous->parent == this );
+                return previous->NextSibling( val );
+        }
+}
+
+
+const TiXmlNode* TiXmlNode::NextSibling( const char * _value ) const
 {
         const TiXmlNode* node;
-        for ( node = lastChild; node; node = node->prev )
+        for ( node = next; node; node = node->next )
         {
                 if ( strcmp( node->Value(), _value ) == 0 )
@@ -355 +401 @@
 }
 
-TiXmlNode* TiXmlNode::LastChild( const char * _value )
-{
-        TiXmlNode* node;
-        for ( node = lastChild; node; node = node->prev )
+
+const TiXmlNode* TiXmlNode::PreviousSibling( const char * _value ) const
+{
+        const TiXmlNode* node;
+        for ( node = prev; node; node = node->prev )
         {
                 if ( strcmp( node->Value(), _value ) == 0 )
@@ -366 +413 @@
 }
 
-const TiXmlNode* TiXmlNode::IterateChildren( const TiXmlNode* previous ) const
-{
-        if ( !previous )
-        {
-                return FirstChild();
-        }
-        else
-        {
-                assert( previous->parent == this );
-                return previous->NextSibling();
-        }
-}
-
-TiXmlNode* TiXmlNode::IterateChildren( TiXmlNode* previous )
-{
-        if ( !previous )
-        {
-                return FirstChild();
-        }
-        else
-        {
-                assert( previous->parent == this );
-                return previous->NextSibling();
-        }
-}
-
-const TiXmlNode* TiXmlNode::IterateChildren( const char * val, const TiXmlNode* previous ) const
-{
-        if ( !previous )
-        {
-                return FirstChild( val );
-        }
-        else
-        {
-                assert( previous->parent == this );
-                return previous->NextSibling( val );
-        }
-}
-
-TiXmlNode* TiXmlNode::IterateChildren( const char * val, TiXmlNode* previous )
-{
-        if ( !previous )
-        {
-                return FirstChild( val );
-        }
-        else
-        {
-                assert( previous->parent == this );
-                return previous->NextSibling( val );
-        }
-}
-
-const TiXmlNode* TiXmlNode::NextSibling( const char * _value ) const 
-{
-        const TiXmlNode* node;
-        for ( node = next; node; node = node->next )
-        {
-                if ( strcmp( node->Value(), _value ) == 0 )
-                        return node;
-        }
-        return 0;
-}
-
-TiXmlNode* TiXmlNode::NextSibling( const char * _value )
-{
-        TiXmlNode* node;
-        for ( node = next; node; node = node->next )
-        {
-                if ( strcmp( node->Value(), _value ) == 0 )
-                        return node;
-        }
-        return 0;
-}
-
-const TiXmlNode* TiXmlNode::PreviousSibling( const char * _value ) const
-{
-        const TiXmlNode* node;
-        for ( node = prev; node; node = node->prev )
-        {
-                if ( strcmp( node->Value(), _value ) == 0 )
-                        return node;
-        }
-        return 0;
-}
-
-TiXmlNode* TiXmlNode::PreviousSibling( const char * _value )
-{
-        TiXmlNode* node;
-        for ( node = prev; node; node = node->prev )
-        {
-                if ( strcmp( node->Value(), _value ) == 0 )
-                        return node;
-        }
-        return 0;
-}
 
 void TiXmlElement::RemoveAttribute( const char * name )
 {
+    #ifdef TIXML_USE_STL
+        TIXML_STRING str( name );
+        TiXmlAttribute* node = attributeSet.Find( str );
+        #else
         TiXmlAttribute* node = attributeSet.Find( name );
+        #endif
         if ( node )
         {
@@ -486 +443 @@
 }
 
-TiXmlElement* TiXmlNode::FirstChildElement()
-{
-        TiXmlNode* node;
-
-        for (   node = FirstChild();
-                        node;
-                        node = node->NextSibling() )
-        {
-                if ( node->ToElement() )
-                        return node->ToElement();
-        }
-        return 0;
-}
 
 const TiXmlElement* TiXmlNode::FirstChildElement( const char * _value ) const
@@ -514 +458 @@
 }
 
-TiXmlElement* TiXmlNode::FirstChildElement( const char * _value )
-{
-        TiXmlNode* node;
-
-        for (   node = FirstChild( _value );
+
+const TiXmlElement* TiXmlNode::NextSiblingElement() const
+{
+        const TiXmlNode* node;
+
+        for (   node = NextSibling();
+                        node;
+                        node = node->NextSibling() )
+        {
+                if ( node->ToElement() )
+                        return node->ToElement();
+        }
+        return 0;
+}
+
+
+const TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value ) const
+{
+        const TiXmlNode* node;
+
+        for (   node = NextSibling( _value );
                         node;
                         node = node->NextSibling( _value ) )
@@ -528 +488 @@
 }
 
-const TiXmlElement* TiXmlNode::NextSiblingElement() const
-{
-        const TiXmlNode* node;
-
-        for (   node = NextSibling();
-        node;
-        node = node->NextSibling() )
-        {
-                if ( node->ToElement() )
-                        return node->ToElement();
-        }
-        return 0;
-}
-
-TiXmlElement* TiXmlNode::NextSiblingElement()
-{
-        TiXmlNode* node;
-
-        for (   node = NextSibling();
-        node;
-        node = node->NextSibling() )
-        {
-                if ( node->ToElement() )
-                        return node->ToElement();
-        }
-        return 0;
-}
-
-const TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value ) const
-{
-        const TiXmlNode* node;
-
-        for (   node = NextSibling( _value );
-        node;
-        node = node->NextSibling( _value ) )
-        {
-                if ( node->ToElement() )
-                        return node->ToElement();
-        }
-        return 0;
-}
-
-TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value )
-{
-        TiXmlNode* node;
-
-        for (   node = NextSibling( _value );
-        node;
-        node = node->NextSibling( _value ) )
-        {
-                if ( node->ToElement() )
-                        return node->ToElement();
-        }
-        return 0;
-}
-
 
 const TiXmlDocument* TiXmlNode::GetDocument() const
@@ -597 +501 @@
 }
 
-TiXmlDocument* TiXmlNode::GetDocument()
-{
-        TiXmlNode* node;
-
-        for( node = this; node; node = node->parent )
-        {
-                if ( node->ToDocument() )
-                        return node->ToDocument();
-        }
-        return 0;
-}
 
 TiXmlElement::TiXmlElement (const char * _value)
@@ -618 +511 @@
 
 #ifdef TIXML_USE_STL
-TiXmlElement::TiXmlElement( const std::string& _value ) 
+TiXmlElement::TiXmlElement( const std::string& _value )
         : TiXmlNode( TiXmlNode::ELEMENT )
 {
@@ -631 +524 @@
 {
         firstChild = lastChild = 0;
-        copy.CopyTo( this );    
+        copy.CopyTo( this );
 }
 
@@ -660 +553 @@
 
 
-const char * TiXmlElement::Attribute( const char * name ) const
+const char* TiXmlElement::Attribute( const char* name ) const
 {
         const TiXmlAttribute* node = attributeSet.Find( name );
-
         if ( node )
                 return node->Value();
-
         return 0;
 }
 
 
-const char * TiXmlElement::Attribute( const char * name, int* i ) const
-{
-        const char * s = Attribute( name );
+#ifdef TIXML_USE_STL
+const std::string* TiXmlElement::Attribute( const std::string& name ) const
+{
+        const TiXmlAttribute* node = attributeSet.Find( name );
+        if ( node )
+                return &node->ValueStr();
+        return 0;
+}
+#endif
+
+
+const char* TiXmlElement::Attribute( const char* name, int* i ) const
+{
+        const char* s = Attribute( name );
         if ( i )
         {
-                if ( s )
+                if ( s ) {
                         *i = atoi( s );
-                else
+                }
+                else {
                         *i = 0;
+                }
         }
         return s;
@@ -685 +589 @@
 
 
-const char * TiXmlElement::Attribute( const char * name, double* d ) const
-{
-        const char * s = Attribute( name );
+#ifdef TIXML_USE_STL
+const std::string* TiXmlElement::Attribute( const std::string& name, int* i ) const
+{
+        const std::string* s = Attribute( name );
+        if ( i )
+        {
+                if ( s ) {
+                        *i = atoi( s->c_str() );
+                }
+                else {
+                        *i = 0;
+                }
+        }
+        return s;
+}
+#endif
+
+
+const char* TiXmlElement::Attribute( const char* name, double* d ) const
+{
+        const char* s = Attribute( name );
         if ( d )
         {
-                if ( s )
+                if ( s ) {
                         *d = atof( s );
-                else
+                }
+                else {
                         *d = 0;
+                }
         }
         return s;
 }
+
+
+#ifdef TIXML_USE_STL
+const std::string* TiXmlElement::Attribute( const std::string& name, double* d ) const
+{
+        const std::string* s = Attribute( name );
+        if ( d )
+        {
+                if ( s ) {
+                        *d = atof( s->c_str() );
+                }
+                else {
+                        *d = 0;
+                }
+        }
+        return s;
+}
+#endif
 
 
@@ -704 +646 @@
         if ( !node )
                 return TIXML_NO_ATTRIBUTE;
-
         return node->QueryIntValue( ival );
 }
 
 
-int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval ) const
+#ifdef TIXML_USE_STL
+int TiXmlElement::QueryIntAttribute( const std::string& name, int* ival ) const
 {
         const TiXmlAttribute* node = attributeSet.Find( name );
         if ( !node )
                 return TIXML_NO_ATTRIBUTE;
-
+        return node->QueryIntValue( ival );
+}
+#endif
+
+
+int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval ) const
+{
+        const TiXmlAttribute* node = attributeSet.Find( name );
+        if ( !node )
+                return TIXML_NO_ATTRIBUTE;
         return node->QueryDoubleValue( dval );
 }
 
 
+#ifdef TIXML_USE_STL
+int TiXmlElement::QueryDoubleAttribute( const std::string& name, double* dval ) const
+{
+        const TiXmlAttribute* node = attributeSet.Find( name );
+        if ( !node )
+                return TIXML_NO_ATTRIBUTE;
+        return node->QueryDoubleValue( dval );
+}
+#endif
+
+
 void TiXmlElement::SetAttribute( const char * name, int val )
-{       
+{
         char buf[64];
-        #if defined(TIXML_SNPRINTF)             
+        #if defined(TIXML_SNPRINTF)
                 TIXML_SNPRINTF( buf, sizeof(buf), "%d", val );
         #else
@@ -731 +693 @@
 
 
+#ifdef TIXML_USE_STL
+void TiXmlElement::SetAttribute( const std::string& name, int val )
+{
+   std::ostringstream oss;
+   oss << val;
+   SetAttribute( name, oss.str() );
+}
+#endif
+
+
 void TiXmlElement::SetDoubleAttribute( const char * name, double val )
-{       
+{
         char buf[256];
-        #if defined(TIXML_SNPRINTF)             
+        #if defined(TIXML_SNPRINTF)
                 TIXML_SNPRINTF( buf, sizeof(buf), "%f", val );
         #else
@@ -743 +715 @@
 
 
-void TiXmlElement::SetAttribute( const char * name, const char * _value )
+void TiXmlElement::SetAttribute( const char * cname, const char * cvalue )
+{
+    #ifdef TIXML_USE_STL
+        TIXML_STRING _name( cname );
+        TIXML_STRING _value( cvalue );
+        #else
+        const char* _name = cname;
+        const char* _value = cvalue;
+        #endif
+
+        TiXmlAttribute* node = attributeSet.Find( _name );
+        if ( node )
+        {
+                node->SetValue( _value );
+                return;
+        }
+
+        TiXmlAttribute* attrib = new TiXmlAttribute( cname, cvalue );
+        if ( attrib )
+        {
+                attributeSet.Add( attrib );
+        }
+        else
+        {
+                TiXmlDocument* document = GetDocument();
+                if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN );
+        }
+}
+
+
+#ifdef TIXML_USE_STL
+void TiXmlElement::SetAttribute( const std::string& name, const std::string& _value )
 {
         TiXmlAttribute* node = attributeSet.Find( name );
@@ -763 +766 @@
         }
 }
+#endif
+
 
 void TiXmlElement::Print( FILE* cfile, int depth ) const
 {
         int i;
-        for ( i=0; i<depth; i++ )
-        {
+        assert( cfile );
+        for ( i=0; i<depth; i++ ) {
                 fprintf( cfile, "    " );
         }
@@ -809 +814 @@
                 }
                 fprintf( cfile, "\n" );
-                for( i=0; i<depth; ++i )
-                fprintf( cfile, "    " );
+                for( i=0; i<depth; ++i ) {
+                        fprintf( cfile, "    " );
+                }
                 fprintf( cfile, "</%s>", value.c_str() );
-        }
-}
-
-void TiXmlElement::StreamOut( TIXML_OSTREAM * stream ) const
-{
-        (*stream) << "<" << value;
-
-        const TiXmlAttribute* attrib;
-        for ( attrib = attributeSet.First(); attrib; attrib = attrib->Next() )
-        {       
-                (*stream) << " ";
-                attrib->StreamOut( stream );
-        }
-
-        // If this node has children, give it a closing tag. Else
-        // make it an empty tag.
-        TiXmlNode* node;
-        if ( firstChild )
-        {               
-                (*stream) << ">";
-
-                for ( node = firstChild; node; node=node->NextSibling() )
-                {
-                        node->StreamOut( stream );
-                }
-                (*stream) << "</" << value << ">";
-        }
-        else
-        {
-                (*stream) << " />";
         }
 }
@@ -851 +827 @@
         TiXmlNode::CopyTo( target );
 
-        // Element class: 
+        // Element class:
         // Clone the attributes, then clone the children.
         const TiXmlAttribute* attribute = 0;
@@ -868 +844 @@
 }
 
+bool TiXmlElement::Accept( TiXmlVisitor* visitor ) const
+{
+        if ( visitor->VisitEnter( *this, attributeSet.First() ) )
+        {
+                for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
+                {
+                        if ( !node->Accept( visitor ) )
+                                break;
+                }
+        }
+        return visitor->VisitExit( *this );
+}
+
 
 TiXmlNode* TiXmlElement::Clone() const
@@ -936 +925 @@
 {
         // See STL_STRING_BUG below.
-        StringToBuffer buf( value );
-
-        if ( buf.buffer && LoadFile( buf.buffer, encoding ) )
-                return true;
-
-        return false;
+        //StringToBuffer buf( value );
+
+        return LoadFile( Value(), encoding );
 }
 
@@ -948 +934 @@
 {
         // See STL_STRING_BUG below.
-        StringToBuffer buf( value );
-
-        if ( buf.buffer && SaveFile( buf.buffer ) )
-                return true;
-
-        return false;
-}
-
-bool TiXmlDocument::LoadFile( const char* filename, TiXmlEncoding encoding )
-{
-        // Delete the existing data:
-        Clear();
-        location.Clear();
-
+//      StringToBuffer buf( value );
+//
+//      if ( buf.buffer && SaveFile( buf.buffer ) )
+//              return true;
+//
+//      return false;
+        return SaveFile( Value() );
+}
+
+bool TiXmlDocument::LoadFile( const char* _filename, TiXmlEncoding encoding )
+{
         // There was a really terrifying little bug here. The code:
         //              value = filename
@@ -968 +951 @@
         // address as it's c_str() method, and so bad things happen. Looks
         // like a bug in the Microsoft STL implementation.
-        // See STL_STRING_BUG above.
-        // Fixed with the StringToBuffer class.
+        // Add an extra string to avoid the crash.
+        TIXML_STRING filename( _filename );
         value = filename;
 
         // reading in binary mode so that tinyxml can normalize the EOL
-        FILE* file = fopen( value.c_str (), "rb" );     
+        FILE* file = TiXmlFOpen( value.c_str (), "rb" );
 
         if ( file )
         {
-                // Get the file size, so we can pre-allocate the string. HUGE speed impact.
-                long length = 0;
-                fseek( file, 0, SEEK_END );
-                length = ftell( file );
-                fseek( file, 0, SEEK_SET );
-
-                // Strange case, but good to handle up front.
-                if ( length == 0 )
-                {
-                        fclose( file );
-                        return false;
-                }
-
-                // If we have a file, assume it is all one big XML file, and read it in.
-                // The document parser may decide the document ends sooner than the entire file, however.
-                TIXML_STRING data;
-                data.reserve( length );
-
-                // Subtle bug here. TinyXml did use fgets. But from the XML spec:
-                // 2.11 End-of-Line Handling
-                // <snip>
-                // <quote>
-                // ...the XML processor MUST behave as if it normalized all line breaks in external 
-                // parsed entities (including the document entity) on input, before parsing, by translating 
-                // both the two-character sequence #xD #xA and any #xD that is not followed by #xA to 
-                // a single #xA character.
-                // </quote>
-                //
-                // It is not clear fgets does that, and certainly isn't clear it works cross platform. 
-                // Generally, you expect fgets to translate from the convention of the OS to the c/unix
-                // convention, and not work generally.
-
-                /*
-                while( fgets( buf, sizeof(buf), file ) )
-                {
-                        data += buf;
-                }
-                */
-
-                char* buf = new char[ length+1 ];
-                buf[0] = 0;
-
-                if ( fread( buf, length, 1, file ) != 1 ) {
-                //if ( fread( buf, 1, length, file ) != (size_t)length ) {
-                        SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
-                        fclose( file );
-                        return false;
-                }
+                bool result = LoadFile( file, encoding );
                 fclose( file );
-
-                const char* lastPos = buf;
-                const char* p = buf;
-
-                buf[length] = 0;
-                while( *p ) {
-                        assert( p < (buf+length) );
-                        if ( *p == 0xa ) {
-                                // Newline character. No special rules for this. Append all the characters
-                                // since the last string, and include the newline.
-                                data.append( lastPos, p-lastPos+1 );    // append, include the newline
-                                ++p;                                                                    // move past the newline
-                                lastPos = p;                                                    // and point to the new buffer (may be 0)
+                return result;
+        }
+        else
+        {
+                SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
+                return false;
+        }
+}
+
+bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding )
+{
+        if ( !file )
+        {
+                SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
+                return false;
+        }
+
+        // Delete the existing data:
+        Clear();
+        location.Clear();
+
+        // Get the file size, so we can pre-allocate the string. HUGE speed impact.
+        long length = 0;
+        fseek( file, 0, SEEK_END );
+        length = ftell( file );
+        fseek( file, 0, SEEK_SET );
+
+        // Strange case, but good to handle up front.
+        if ( length <= 0 )
+        {
+                SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );
+                return false;
+        }
+
+        // If we have a file, assume it is all one big XML file, and read it in.
+        // The document parser may decide the document ends sooner than the entire file, however.
+        TIXML_STRING data;
+        data.reserve( length );
+
+        // Subtle bug here. TinyXml did use fgets. But from the XML spec:
+        // 2.11 End-of-Line Handling
+        // <snip>
+        // <quote>
+        // ...the XML processor MUST behave as if it normalized all line breaks in external
+        // parsed entities (including the document entity) on input, before parsing, by translating
+        // both the two-character sequence #xD #xA and any #xD that is not followed by #xA to
+        // a single #xA character.
+        // </quote>
+        //
+        // It is not clear fgets does that, and certainly isn't clear it works cross platform.
+        // Generally, you expect fgets to translate from the convention of the OS to the c/unix
+        // convention, and not work generally.
+
+        /*
+        while( fgets( buf, sizeof(buf), file ) )
+        {
+                data += buf;
+        }
+        */
+
+        char* buf = new char[ length+1 ];
+        buf[0] = 0;
+
+        if ( fread( buf, length, 1, file ) != 1 ) {
+                delete [] buf;
+                SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
+                return false;
+        }
+
+        const char* lastPos = buf;
+        const char* p = buf;
+
+        buf[length] = 0;
+        while( *p ) {
+                assert( p < (buf+length) );
+                if ( *p == 0xa ) {
+                        // Newline character. No special rules for this. Append all the characters
+                        // since the last string, and include the newline.
+                        data.append( lastPos, (p-lastPos+1) );  // append, include the newline
+                        ++p;                                                                    // move past the newline
+                        lastPos = p;                                                    // and point to the new buffer (may be 0)
+                        assert( p <= (buf+length) );
+                }
+                else if ( *p == 0xd ) {
+                        // Carriage return. Append what we have so far, then
+                        // handle moving forward in the buffer.
+                        if ( (p-lastPos) > 0 ) {
+                                data.append( lastPos, p-lastPos );      // do not add the CR
+                        }
+                        data += (char)0xa;                                              // a proper newline
+
+                        if ( *(p+1) == 0xa ) {
+                                // Carriage return - new line sequence
+                                p += 2;
+                                lastPos = p;
                                 assert( p <= (buf+length) );
                         }
-                        else if ( *p == 0xd ) {
-                                // Carriage return. Append what we have so far, then
-                                // handle moving forward in the buffer.
-                                if ( (p-lastPos) > 0 ) {
-                                        data.append( lastPos, p-lastPos );      // do not add the CR
-                                }
-                                data += (char)0xa;                                              // a proper newline
-
-                                if ( *(p+1) == 0xa ) {
-                                        // Carriage return - new line sequence
-                                        p += 2;
-                                        lastPos = p;
-                                        assert( p <= (buf+length) );
-                                }
-                                else {
-                                        // it was followed by something else...that is presumably characters again.
-                                        ++p;
-                                        lastPos = p;
-                                        assert( p <= (buf+length) );
-                                }
+                        else {
+                                // it was followed by something else...that is presumably characters again.
+                                ++p;
+                                lastPos = p;
+                                assert( p <= (buf+length) );
                         }
-                        else {
-                                ++p;
-                        }
-                }
-                // Handle any left over characters.
-                if ( p-lastPos ) {
-                        data.append( lastPos, p-lastPos );
-                }               
-                delete [] buf;
-                buf = 0;
-
-                Parse( data.c_str(), 0, encoding );
-
-                if (  Error() )
-            return false;
-        else
-                        return true;
-        }
-        SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
+                }
+                else {
+                        ++p;
+                }
+        }
+        // Handle any left over characters.
+        if ( p-lastPos ) {
+                data.append( lastPos, p-lastPos );
+        }
+        delete [] buf;
+        buf = 0;
+
+        Parse( data.c_str(), 0, encoding );
+
+        if (  Error() )
+        return false;
+    else
+                return true;
+}
+
+
+bool TiXmlDocument::SaveFile( const char * filename ) const
+{
+        // The old c stuff lives on...
+        FILE* fp = TiXmlFOpen( filename, "w" );
+        if ( fp )
+        {
+                bool result = SaveFile( fp );
+                fclose( fp );
+                return result;
+        }
         return false;
 }
 
-bool TiXmlDocument::SaveFile( const char * filename ) const
-{
-        // The old c stuff lives on...
-        FILE* fp = fopen( filename, "w" );
-        if ( fp )
-        {
-                if ( useMicrosoftBOM ) 
-                {
-                        const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
-                        const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
-                        const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
-
-                        fputc( TIXML_UTF_LEAD_0, fp );
-                        fputc( TIXML_UTF_LEAD_1, fp );
-                        fputc( TIXML_UTF_LEAD_2, fp );
-                }
-                Print( fp, 0 );
-                fclose( fp );
-                return true;
-        }
-        return false;
+
+bool TiXmlDocument::SaveFile( FILE* fp ) const
+{
+        if ( useMicrosoftBOM )
+        {
+                const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
+                const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
+                const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
+
+                fputc( TIXML_UTF_LEAD_0, fp );
+                fputc( TIXML_UTF_LEAD_1, fp );
+                fputc( TIXML_UTF_LEAD_2, fp );
+        }
+        Print( fp, 0 );
+        return (ferror(fp) == 0);
 }
 
@@ -1113 +1122 @@
 
         target->error = error;
-        target->errorDesc = errorDesc.c_str ();
+        target->errorId = errorId;
+        target->errorDesc = errorDesc;
+        target->tabsize = tabsize;
+        target->errorLocation = errorLocation;
+        target->useMicrosoftBOM = useMicrosoftBOM;
 
         TiXmlNode* node = 0;
@@ -1119 +1132 @@
         {
                 target->LinkEndChild( node->Clone() );
-        }       
+        }
 }
 
@@ -1136 +1149 @@
 void TiXmlDocument::Print( FILE* cfile, int depth ) const
 {
-        const TiXmlNode* node;
-        for ( node=FirstChild(); node; node=node->NextSibling() )
+        assert( cfile );
+        for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
         {
                 node->Print( cfile, depth );
@@ -1144 +1157 @@
 }
 
-void TiXmlDocument::StreamOut( TIXML_OSTREAM * out ) const
-{
-        const TiXmlNode* node;
-        for ( node=FirstChild(); node; node=node->NextSibling() )
-        {
-                node->StreamOut( out );
-
-                // Special rule for streams: stop after the root element.
-                // The stream in code will only read one element, so don't
-                // write more than one.
-                if ( node->ToElement() )
-                        break;
-        }
+
+bool TiXmlDocument::Accept( TiXmlVisitor* visitor ) const
+{
+        if ( visitor->VisitEnter( *this ) )
+        {
+                for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
+                {
+                        if ( !node->Accept( visitor ) )
+                                break;
+                }
+        }
+        return visitor->VisitExit( *this );
 }
 
@@ -1169 +1181 @@
 }
 
+/*
 TiXmlAttribute* TiXmlAttribute::Next()
 {
@@ -1177 +1190 @@
         return next;
 }
+*/
 
 const TiXmlAttribute* TiXmlAttribute::Previous() const
@@ -1187 +1201 @@
 }
 
+/*
 TiXmlAttribute* TiXmlAttribute::Previous()
 {
@@ -1195 +1210 @@
         return prev;
 }
-
-void TiXmlAttribute::Print( FILE* cfile, int /*depth*/ ) const
+*/
+
+void TiXmlAttribute::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const
 {
         TIXML_STRING n, v;
 
-        PutString( name, &n );
-        PutString( value, &v );
-
-        if (value.find ('\"') == TIXML_STRING::npos)
+        EncodeString( name, &n );
+        EncodeString( value, &v );
+
+        if (value.find ('\"') == TIXML_STRING::npos) {
+                if ( cfile ) {
                 fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() );
-        else
+                }
+                if ( str ) {
+                        (*str) += n; (*str) += "=\""; (*str) += v; (*str) += "\"";
+                }
+        }
+        else {
+                if ( cfile ) {
                 fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() );
-}
-
-
-void TiXmlAttribute::StreamOut( TIXML_OSTREAM * stream ) const
-{
-        if (value.find( '\"' ) != TIXML_STRING::npos)
-        {
-                PutString( name, stream );
-                (*stream) << "=" << "'";
-                PutString( value, stream );
-                (*stream) << "'";
-        }
-        else
-        {
-                PutString( name, stream );
-                (*stream) << "=" << "\"";
-                PutString( value, stream );
-                (*stream) << "\"";
-        }
-}
+                }
+                if ( str ) {
+                        (*str) += n; (*str) += "='"; (*str) += v; (*str) += "'";
+                }
+        }
+}
+
 
 int TiXmlAttribute::QueryIntValue( int* ival ) const
 {
-        if ( sscanf( value.c_str(), "%d", ival ) == 1 )
+        if ( TIXML_SSCANF( value.c_str(), "%d", ival ) == 1 )
                 return TIXML_SUCCESS;
         return TIXML_WRONG_TYPE;
@@ -1237 +1247 @@
 int TiXmlAttribute::QueryDoubleValue( double* dval ) const
 {
-        if ( sscanf( value.c_str(), "%lf", dval ) == 1 )
+        if ( TIXML_SSCANF( value.c_str(), "%lf", dval ) == 1 )
                 return TIXML_SUCCESS;
         return TIXML_WRONG_TYPE;
@@ -1245 +1255 @@
 {
         char buf [64];
-        #if defined(TIXML_SNPRINTF)             
+        #if defined(TIXML_SNPRINTF)
                 TIXML_SNPRINTF(buf, sizeof(buf), "%d", _value);
         #else
@@ -1256 +1266 @@
 {
         char buf [256];
-        #if defined(TIXML_SNPRINTF)             
+        #if defined(TIXML_SNPRINTF)
                 TIXML_SNPRINTF( buf, sizeof(buf), "%lf", _value);
         #else
@@ -1290 +1300 @@
 void TiXmlComment::Print( FILE* cfile, int depth ) const
 {
+        assert( cfile );
         for ( int i=0; i<depth; i++ )
         {
-                fputs( "    ", cfile );
+                fprintf( cfile,  "    " );
         }
         fprintf( cfile, "<!--%s-->", value.c_str() );
 }
 
-void TiXmlComment::StreamOut( TIXML_OSTREAM * stream ) const
-{
-        (*stream) << "<!--";
-        //PutString( value, stream );
-        (*stream) << value;
-        (*stream) << "-->";
-}
-
 
 void TiXmlComment::CopyTo( TiXmlComment* target ) const
 {
         TiXmlNode::CopyTo( target );
+}
+
+
+bool TiXmlComment::Accept( TiXmlVisitor* visitor ) const
+{
+        return visitor->Visit( *this );
 }
 
@@ -1326 +1335 @@
 void TiXmlText::Print( FILE* cfile, int depth ) const
 {
+        assert( cfile );
         if ( cdata )
         {
@@ -1333 +1343 @@
                         fprintf( cfile, "    " );
                 }
-                fprintf( cfile, "<![CDATA[" );
-                fprintf( cfile, "%s", value.c_str() );  // unformatted output
-                fprintf( cfile, "]]>\n" );
+                fprintf( cfile, "<![CDATA[%s]]>\n", value.c_str() );    // unformatted output
         }
         else
         {
                 TIXML_STRING buffer;
-                PutString( value, &buffer );
+                EncodeString( value, &buffer );
                 fprintf( cfile, "%s", buffer.c_str() );
-        }
-}
-
-
-void TiXmlText::StreamOut( TIXML_OSTREAM * stream ) const
-{
-        if ( cdata )
-        {
-                (*stream) << "<![CDATA[" << value << "]]>";
-        }
-        else
-        {
-                PutString( value, stream );
         }
 }
@@ -1366 +1361 @@
 
 
+bool TiXmlText::Accept( TiXmlVisitor* visitor ) const
+{
+        return visitor->Visit( *this );
+}
+
+
 TiXmlNode* TiXmlText::Clone() const
-{       
+{
         TiXmlText* clone = 0;
         clone = new TiXmlText( "" );
@@ -1406 +1407 @@
         : TiXmlNode( TiXmlNode::DECLARATION )
 {
-        copy.CopyTo( this );    
+        copy.CopyTo( this );
 }
 
@@ -1417 +1418 @@
 
 
-void TiXmlDeclaration::Print( FILE* cfile, int /*depth*/ ) const
-{
-        fprintf (cfile, "<?xml ");
-
-        if ( !version.empty() )
-                fprintf (cfile, "version=\"%s\" ", version.c_str ());
-        if ( !encoding.empty() )
-                fprintf (cfile, "encoding=\"%s\" ", encoding.c_str ());
-        if ( !standalone.empty() )
-                fprintf (cfile, "standalone=\"%s\" ", standalone.c_str ());
-        fprintf (cfile, "?>");
-}
-
-void TiXmlDeclaration::StreamOut( TIXML_OSTREAM * stream ) const
-{
-        (*stream) << "<?xml ";
-
-        if ( !version.empty() )
-        {
-                (*stream) << "version=\"";
-                PutString( version, stream );
-                (*stream) << "\" ";
-        }
-        if ( !encoding.empty() )
-        {
-                (*stream) << "encoding=\"";
-                PutString( encoding, stream );
-                (*stream ) << "\" ";
-        }
-        if ( !standalone.empty() )
-        {
-                (*stream) << "standalone=\"";
-                PutString( standalone, stream );
-                (*stream) << "\" ";
-        }
-        (*stream) << "?>";
+void TiXmlDeclaration::Print( FILE* cfile, int /*depth*/, TIXML_STRING* str ) const
+{
+        if ( cfile ) fprintf( cfile, "<?xml " );
+        if ( str )       (*str) += "<?xml ";
+
+        if ( !version.empty() ) {
+                if ( cfile ) fprintf (cfile, "version=\"%s\" ", version.c_str ());
+                if ( str ) { (*str) += "version=\""; (*str) += version; (*str) += "\" "; }
+        }
+        if ( !encoding.empty() ) {
+                if ( cfile ) fprintf (cfile, "encoding=\"%s\" ", encoding.c_str ());
+                if ( str ) { (*str) += "encoding=\""; (*str) += encoding; (*str) += "\" "; }
+        }
+        if ( !standalone.empty() ) {
+                if ( cfile ) fprintf (cfile, "standalone=\"%s\" ", standalone.c_str ());
+                if ( str ) { (*str) += "standalone=\""; (*str) += standalone; (*str) += "\" "; }
+        }
+        if ( cfile ) fprintf( cfile, "?>" );
+        if ( str )       (*str) += "?>";
 }
 
@@ -1466 +1450 @@
 
 
+bool TiXmlDeclaration::Accept( TiXmlVisitor* visitor ) const
+{
+        return visitor->Visit( *this );
+}
+
+
 TiXmlNode* TiXmlDeclaration::Clone() const
-{       
+{
         TiXmlDeclaration* clone = new TiXmlDeclaration();
 
@@ -1486 +1476 @@
 
 
-void TiXmlUnknown::StreamOut( TIXML_OSTREAM * stream ) const
-{
-        (*stream) << "<" << value << ">";               // Don't use entities here! It is unknown.
-}
-
-
 void TiXmlUnknown::CopyTo( TiXmlUnknown* target ) const
 {
         TiXmlNode::CopyTo( target );
+}
+
+
+bool TiXmlUnknown::Accept( TiXmlVisitor* visitor ) const
+{
+        return visitor->Visit( *this );
 }
 
@@ -1526 +1516 @@
 void TiXmlAttributeSet::Add( TiXmlAttribute* addMe )
 {
+    #ifdef TIXML_USE_STL
+        assert( !Find( TIXML_STRING( addMe->Name() ) ) );       // Shouldn't be multiply adding to the set.
+        #else
         assert( !Find( addMe->Name() ) );       // Shouldn't be multiply adding to the set.
+        #endif
 
         addMe->next = &sentinel;
@@ -1553 +1547 @@
 }
 
-const TiXmlAttribute* TiXmlAttributeSet::Find( const char * name ) const
-{
-        const TiXmlAttribute* node;
-
-        for( node = sentinel.next; node != &sentinel; node = node->next )
+
+#ifdef TIXML_USE_STL
+const TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) const
+{
+        for( const TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next )
         {
                 if ( node->name == name )
@@ -1565 +1559 @@
 }
 
-TiXmlAttribute* TiXmlAttributeSet::Find( const char * name )
-{
-        TiXmlAttribute* node;
-
-        for( node = sentinel.next; node != &sentinel; node = node->next )
+/*
+TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name )
+{
+        for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next )
         {
                 if ( node->name == name )
@@ -1576 +1569 @@
         return 0;
 }
-
-#ifdef TIXML_USE_STL    
-TIXML_ISTREAM & operator >> (TIXML_ISTREAM & in, TiXmlNode & base)
+*/
+#endif
+
+
+const TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const
+{
+        for( const TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next )
+        {
+                if ( strcmp( node->name.c_str(), name ) == 0 )
+                        return node;
+        }
+        return 0;
+}
+
+/*
+TiXmlAttribute* TiXmlAttributeSet::Find( const char* name )
+{
+        for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next )
+        {
+                if ( strcmp( node->name.c_str(), name ) == 0 )
+                        return node;
+        }
+        return 0;
+}
+*/
+
+#ifdef TIXML_USE_STL
+std::istream& operator>> (std::istream & in, TiXmlNode & base)
 {
         TIXML_STRING tag;
@@ -1590 +1608 @@
 
 
-TIXML_OSTREAM & operator<< (TIXML_OSTREAM & out, const TiXmlNode & base)
-{
-        base.StreamOut (& out);
+#ifdef TIXML_USE_STL
+std::ostream& operator<< (std::ostream & out, const TiXmlNode & base)
+{
+        TiXmlPrinter printer;
+        printer.SetStreamPrinting();
+        base.Accept( &printer );
+        out << printer.Str();
+
         return out;
 }
 
 
-#ifdef TIXML_USE_STL    
-std::string & operator<< (std::string& out, const TiXmlNode& base )
-{
-   std::ostringstream os_stream( std::ostringstream::out );
-   base.StreamOut( &os_stream );
-   
-   out.append( os_stream.str() );
-   return out;
+std::string& operator<< (std::string& out, const TiXmlNode& base )
+{
+        TiXmlPrinter printer;
+        printer.SetStreamPrinting();
+        base.Accept( &printer );
+        out.append( printer.Str() );
+
+        return out;
 }
 #endif
@@ -1731 +1754 @@
         return TiXmlHandle( 0 );
 }
+
+
+bool TiXmlPrinter::VisitEnter( const TiXmlDocument& )
+{
+        return true;
+}
+
+bool TiXmlPrinter::VisitExit( const TiXmlDocument& )
+{
+        return true;
+}
+
+bool TiXmlPrinter::VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute )
+{
+        DoIndent();
+        buffer += "<";
+        buffer += element.Value();
+
+        for( const TiXmlAttribute* attrib = firstAttribute; attrib; attrib = attrib->Next() )
+        {
+                buffer += " ";
+                attrib->Print( 0, 0, &buffer );
+        }
+
+        if ( !element.FirstChild() )
+        {
+                buffer += " />";
+                DoLineBreak();
+        }
+        else
+        {
+                buffer += ">";
+                if (    element.FirstChild()->ToText()
+                          && element.LastChild() == element.FirstChild()
+                          && element.FirstChild()->ToText()->CDATA() == false )
+                {
+                        simpleTextPrint = true;
+                        // no DoLineBreak()!
+                }
+                else
+                {
+                        DoLineBreak();
+                }
+        }
+        ++depth;
+        return true;
+}
+
+
+bool TiXmlPrinter::VisitExit( const TiXmlElement& element )
+{
+        --depth;
+        if ( !element.FirstChild() )
+        {
+                // nothing.
+        }
+        else
+        {
+                if ( simpleTextPrint )
+                {
+                        simpleTextPrint = false;
+                }
+                else
+                {
+                        DoIndent();
+                }
+                buffer += "</";
+                buffer += element.Value();
+                buffer += ">";
+                DoLineBreak();
+        }
+        return true;
+}
+
+
+bool TiXmlPrinter::Visit( const TiXmlText& text )
+{
+        if ( text.CDATA() )
+        {
+                DoIndent();
+                buffer += "<![CDATA[";
+                buffer += text.Value();
+                buffer += "]]>";
+                DoLineBreak();
+        }
+        else if ( simpleTextPrint )
+        {
+                TIXML_STRING str;
+                TiXmlBase::EncodeString( text.ValueTStr(), &str );
+                buffer += str;
+        }
+        else
+        {
+                DoIndent();
+                TIXML_STRING str;
+                TiXmlBase::EncodeString( text.ValueTStr(), &str );
+                buffer += str;
+                DoLineBreak();
+        }
+        return true;
+}
+
+
+bool TiXmlPrinter::Visit( const TiXmlDeclaration& declaration )
+{
+        DoIndent();
+        declaration.Print( 0, 0, &buffer );
+        DoLineBreak();
+        return true;
+}
+
+
+bool TiXmlPrinter::Visit( const TiXmlComment& comment )
+{
+        DoIndent();
+        buffer += "<!--";
+        buffer += comment.Value();
+        buffer += "-->";
+        DoLineBreak();
+        return true;
+}
+
+
+bool TiXmlPrinter::Visit( const TiXmlUnknown& unknown )
+{
+        DoIndent();
+        buffer += "<";
+        buffer += unknown.Value();
+        buffer += ">";
+        DoLineBreak();
+        return true;
+}
+

code/branches/FICN/src/tinyxml/tinyxml.h

@@ -1 +1 @@
 /*
 www.sourceforge.net/projects/tinyxml
-Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
+Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)
 
 This software is provided 'as-is', without any express or implied
@@ -26 +26 @@
 #ifndef TINYXML_INCLUDED
 #define TINYXML_INCLUDED
-
-#define TIXML_USE_STL
 
 #ifdef _MSC_VER
@@ -46 +44 @@
 #endif
 
-#if defined( DEBUG ) && defined( _MSC_VER )
-#include <windows.h>
-#define TIXML_LOG OutputDebugString
-#else
-#define TIXML_LOG printf
-#endif
-
 #ifdef TIXML_USE_STL
         #include <string>
         #include <iostream>
-        #define TIXML_STRING    std::string
-        #define TIXML_ISTREAM   std::istream
-        #define TIXML_OSTREAM   std::ostream
+        #include <sstream>
+        #define TIXML_STRING            std::string
 #else
         #include "tinystr.h"
-        #define TIXML_STRING    TiXmlString
-        #define TIXML_OSTREAM   TiXmlOutStream
+        #define TIXML_STRING            TiXmlString
 #endif
 
@@ -69 +58 @@
 // but it gets closer. There are too many compilers for me to fully
 // test. If you get compilation troubles, undefine TIXML_SAFE
-
-#define TIXML_SAFE              // TinyXml isn't fully buffer overrun protected, safe code. This is work in progress.
+#define TIXML_SAFE
+
 #ifdef TIXML_SAFE
-        #if defined(_MSC_VER) && (_MSC_VER >= 1200 )
+        #if defined(_MSC_VER) && (_MSC_VER >= 1400 )
+                // Microsoft visual studio, version 2005 and higher.
+                #define TIXML_SNPRINTF _snprintf_s
+                #define TIXML_SNSCANF  _snscanf_s
+                #define TIXML_SSCANF   sscanf_s
+        #elif defined(_MSC_VER) && (_MSC_VER >= 1200 )
                 // Microsoft visual studio, version 6 and higher.
                 //#pragma message( "Using _sn* functions." )
                 #define TIXML_SNPRINTF _snprintf
                 #define TIXML_SNSCANF  _snscanf
+                #define TIXML_SSCANF   sscanf
         #elif defined(__GNUC__) && (__GNUC__ >= 3 )
                 // GCC version 3 and higher.s
@@ -82 +77 @@
                 #define TIXML_SNPRINTF snprintf
                 #define TIXML_SNSCANF  snscanf
-        #endif
-#endif
+                #define TIXML_SSCANF   sscanf
+        #else
+                #define TIXML_SSCANF   sscanf
+        #endif
+#endif  
 
 class TiXmlDocument;
@@ -95 +93 @@
 
 const int TIXML_MAJOR_VERSION = 2;
-const int TIXML_MINOR_VERSION = 4;
-const int TIXML_PATCH_VERSION = 2;
-
-/*      Internal structure for tracking location of items
+const int TIXML_MINOR_VERSION = 5;
+const int TIXML_PATCH_VERSION = 3;
+
+/*      Internal structure for tracking location of items 
         in the XML file.
 */
@@ -111 +109 @@
 
 
+/**
+        If you call the Accept() method, it requires being passed a TiXmlVisitor
+        class to handle callbacks. For nodes that contain other nodes (Document, Element)
+        you will get called with a VisitEnter/VisitExit pair. Nodes that are always leaves
+        are simple called with Visit().
+
+        If you return 'true' from a Visit method, recursive parsing will continue. If you return
+        false, <b>no children of this node or its sibilings</b> will be Visited.
+
+        All flavors of Visit methods have a default implementation that returns 'true' (continue 
+        visiting). You need to only override methods that are interesting to you.
+
+        Generally Accept() is called on the TiXmlDocument, although all nodes suppert Visiting.
+
+        You should never change the document from a callback.
+
+        @sa TiXmlNode::Accept()
+*/
+class TiXmlVisitor
+{
+public:
+        virtual ~TiXmlVisitor() {}
+
+        /// Visit a document.
+        virtual bool VisitEnter( const TiXmlDocument& /*doc*/ )                 { return true; }
+        /// Visit a document.
+        virtual bool VisitExit( const TiXmlDocument& /*doc*/ )                  { return true; }
+
+        /// Visit an element.
+        virtual bool VisitEnter( const TiXmlElement& /*element*/, const TiXmlAttribute* /*firstAttribute*/ )    { return true; }
+        /// Visit an element.
+        virtual bool VisitExit( const TiXmlElement& /*element*/ )               { return true; }
+
+        /// Visit a declaration
+        virtual bool Visit( const TiXmlDeclaration& /*declaration*/ )   { return true; }
+        /// Visit a text node
+        virtual bool Visit( const TiXmlText& /*text*/ )                                 { return true; }
+        /// Visit a comment node
+        virtual bool Visit( const TiXmlComment& /*comment*/ )                   { return true; }
+        /// Visit an unknow node
+        virtual bool Visit( const TiXmlUnknown& /*unknown*/ )                   { return true; }
+};
+
 // Only used by Attribute::Query functions
-enum
-{
+enum 
+{ 
         TIXML_SUCCESS,
         TIXML_NO_ATTRIBUTE,
@@ -159 +200 @@
 
 public:
-        TiXmlBase()     :       userData(0) {}
-        virtual ~TiXmlBase()                                    {}
-
-        /**     All TinyXml classes can print themselves to a filestream.
-                This is a formatted print, and will insert tabs and newlines.
-
+        TiXmlBase()     :       userData(0)             {}
+        virtual ~TiXmlBase()                    {}
+
+        /**     All TinyXml classes can print themselves to a filestream
+                or the string class (TiXmlString in non-STL mode, std::string
+                in STL mode.) Either or both cfile and str can be null.
+                
+                This is a formatted print, and will insert 
+                tabs and newlines.
+                
                 (For an unformatted stream, use the << operator.)
         */
@@ -173 +218 @@
                 are provided to set whether or not TinyXml will condense all white space
                 into a single space or not. The default is to condense. Note changing this
-                values is not thread safe.
+                value is not thread safe.
         */
         static void SetCondenseWhiteSpace( bool condense )              { condenseWhiteSpace = condense; }
@@ -201 +246 @@
         int Column() const              { return location.col + 1; }    ///< See Row()
 
-        void  SetUserData( void* user )                 { userData = user; }
-        void* GetUserData()                                             { return userData; }
+        void  SetUserData( void* user )                 { userData = user; }    ///< Set a pointer to arbitrary user data.
+        void* GetUserData()                                             { return userData; }    ///< Get a pointer to arbitrary user data.
+        const void* GetUserData() const                 { return userData; }    ///< Get a pointer to arbitrary user data.
 
         // Table that returs, for a given lead byte, the total number of bytes
@@ -208 +254 @@
         static const int utf8ByteTable[256];
 
-        virtual const char* Parse(      const char* p,
-                                                                TiXmlParsingData* data,
+        virtual const char* Parse(      const char* p, 
+                                                                TiXmlParsingData* data, 
                                                                 TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0;
+
+        /** Expands entities in a string. Note this should not contian the tag's '<', '>', etc, 
+                or they will be transformed into entities!
+        */
+        static void EncodeString( const TIXML_STRING& str, TIXML_STRING* out );
 
         enum
@@ -230 +281 @@
                 TIXML_ERROR_EMBEDDED_NULL,
                 TIXML_ERROR_PARSING_CDATA,
+                TIXML_ERROR_DOCUMENT_TOP_ONLY,
 
                 TIXML_ERROR_STRING_COUNT
@@ -236 +288 @@
 protected:
 
-        // See STL_STRING_BUG
-        // Utility class to overcome a bug.
-        class StringToBuffer
-        {
-          public:
-                StringToBuffer( const TIXML_STRING& str );
-                ~StringToBuffer();
-                char* buffer;
-        };
-
-        static const char*      SkipWhiteSpace( const char*, TiXmlEncoding encoding );
-        inline static bool      IsWhiteSpace( char c )
-        {
-                return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' );
-        }
-
-        virtual void StreamOut (TIXML_OSTREAM *) const = 0;
+        static const char* SkipWhiteSpace( const char*, TiXmlEncoding encoding );
+        inline static bool IsWhiteSpace( char c )               
+        { 
+                return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' ); 
+        }
+        inline static bool IsWhiteSpace( int c )
+        {
+                if ( c < 256 )
+                        return IsWhiteSpace( (char) c );
+                return false;   // Again, only truly correct for English/Latin...but usually works.
+        }
 
         #ifdef TIXML_USE_STL
-            static bool StreamWhiteSpace( TIXML_ISTREAM * in, TIXML_STRING * tag );
-            static bool StreamTo( TIXML_ISTREAM * in, int character, TIXML_STRING * tag );
+        static bool     StreamWhiteSpace( std::istream * in, TIXML_STRING * tag );
+        static bool StreamTo( std::istream * in, int character, TIXML_STRING * tag );
         #endif
 
@@ -285 +331 @@
                 if ( encoding == TIXML_ENCODING_UTF8 )
                 {
-                        *length = utf8ByteTable[ *((unsigned char*)p) ];
+                        *length = utf8ByteTable[ *((const unsigned char*)p) ];
                         assert( *length >= 0 && *length < 5 );
                 }
@@ -316 +362 @@
         }
 
-        // Puts a string to a stream, expanding entities as it goes.
-        // Note this should not contian the '<', '>', etc, or they will be transformed into entities!
-        static void PutString( const TIXML_STRING& str, TIXML_OSTREAM* out );
-
-        static void PutString( const TIXML_STRING& str, TIXML_STRING* out );
-
         // Return true if the next characters in the stream are any of the endTag sequences.
         // Ignore case only works for english, and should only be relied on when comparing
@@ -336 +376 @@
     /// Field containing a generic user pointer
         void*                   userData;
-
+        
         // None of these methods are reliable for any language except English.
         // Good for approximation, not great for accuracy.
@@ -388 +428 @@
 
 public:
-        #ifdef TIXML_USE_STL
+        #ifdef TIXML_USE_STL    
 
             /** An input stream operator, for every class. Tolerant of newlines and
@@ -402 +442 @@
                     a node to a stream is very well defined. You'll get a nice stream
                     of output, without any extra whitespace or newlines.
-
+                    
                     But reading is not as well defined. (As it always is.) If you create
                     a TiXmlElement (for example) and read that from an input stream,
@@ -410 +450 @@
                     A TiXmlDocument will read nodes until it reads a root element, and
                         all the children of that root element.
-            */
+            */  
             friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
 
@@ -416 +456 @@
                 friend std::string& operator<< (std::string& out, const TiXmlNode& base );
 
-        #else
-            // Used internally, not part of the public API.
-            friend TIXML_OSTREAM& operator<< (TIXML_OSTREAM& out, const TiXmlNode& base);
         #endif
 
@@ -459 +496 @@
         #endif
 
+        const TIXML_STRING& ValueTStr() const { return value; }
+
         /** Changes the value of the node. Defined as:
                 @verbatim
@@ -472 +511 @@
     #ifdef TIXML_USE_STL
         /// STL std::string form.
-        void SetValue( const std::string& _value )
-        {
-                StringToBuffer buf( _value );
-                SetValue( buf.buffer ? buf.buffer : "" );
-        }
+        void SetValue( const std::string& _value )      { value = _value; }
         #endif
 
@@ -486 +521 @@
         const TiXmlNode* Parent() const                         { return parent; }
 
-        const TiXmlNode* FirstChild()   const   { return firstChild; }          ///< The first child of this node. Will be null if there are no children.
-        TiXmlNode* FirstChild()                                 { return firstChild; }
+        const TiXmlNode* FirstChild()   const           { return firstChild; }  ///< The first child of this node. Will be null if there are no children.
+        TiXmlNode* FirstChild()                                         { return firstChild; }
         const TiXmlNode* FirstChild( const char * value ) const;                        ///< The first child of this node with the matching 'value'. Will be null if none found.
-        TiXmlNode* FirstChild( const char * value );                                            ///< The first child of this node with the matching 'value'. Will be null if none found.
-
+        /// The first child of this node with the matching 'value'. Will be null if none found.
+        TiXmlNode* FirstChild( const char * _value ) {
+                // Call through to the const version - safe since nothing is changed. Exiting syntax: cast this to a const (always safe)
+                // call the method, cast the return back to non-const.
+                return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->FirstChild( _value ));
+        }
         const TiXmlNode* LastChild() const      { return lastChild; }           /// The last child of this node. Will be null if there are no children.
         TiXmlNode* LastChild()  { return lastChild; }
+        
         const TiXmlNode* LastChild( const char * value ) const;                 /// The last child of this node matching 'value'. Will be null if there are no children.
-        TiXmlNode* LastChild( const char * value );
+        TiXmlNode* LastChild( const char * _value ) {
+                return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode* >(this))->LastChild( _value ));
+        }
 
     #ifdef TIXML_USE_STL
@@ -520 +562 @@
         */
         const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const;
-        TiXmlNode* IterateChildren( TiXmlNode* previous );
+        TiXmlNode* IterateChildren( const TiXmlNode* previous ) {
+                return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( previous ) );
+        }
 
         /// This flavor of IterateChildren searches for children with a particular 'value'
         const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const;
-        TiXmlNode* IterateChildren( const char * value, TiXmlNode* previous );
+        TiXmlNode* IterateChildren( const char * _value, const TiXmlNode* previous ) {
+                return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->IterateChildren( _value, previous ) );
+        }
 
     #ifdef TIXML_USE_STL
         const TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) const  {       return IterateChildren (_value.c_str (), previous);     }       ///< STL std::string form.
-        TiXmlNode* IterateChildren( const std::string& _value, TiXmlNode* previous ) {  return IterateChildren (_value.c_str (), previous);     }       ///< STL std::string form.
+        TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode* previous ) {    return IterateChildren (_value.c_str (), previous);     }       ///< STL std::string form.
         #endif
 
@@ -572 +618 @@
         /// Navigate to a sibling node.
         const TiXmlNode* PreviousSibling( const char * ) const;
-        TiXmlNode* PreviousSibling( const char * );
+        TiXmlNode* PreviousSibling( const char *_prev ) {
+                return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->PreviousSibling( _prev ) );
+        }
 
     #ifdef TIXML_USE_STL
@@ -587 +635 @@
         /// Navigate to a sibling node with the given 'value'.
         const TiXmlNode* NextSibling( const char * ) const;
-        TiXmlNode* NextSibling( const char * );
+        TiXmlNode* NextSibling( const char* _next ) {
+                return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode* >(this))->NextSibling( _next ) );
+        }
 
         /** Convenience function to get through elements.
@@ -594 +644 @@
         */
         const TiXmlElement* NextSiblingElement() const;
-        TiXmlElement* NextSiblingElement();
+        TiXmlElement* NextSiblingElement() {
+                return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement() );
+        }
 
         /** Convenience function to get through elements.
@@ -601 +653 @@
         */
         const TiXmlElement* NextSiblingElement( const char * ) const;
-        TiXmlElement* NextSiblingElement( const char * );
+        TiXmlElement* NextSiblingElement( const char *_next ) {
+                return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->NextSiblingElement( _next ) );
+        }
 
     #ifdef TIXML_USE_STL
@@ -610 +664 @@
         /// Convenience function to get through elements.
         const TiXmlElement* FirstChildElement() const;
-        TiXmlElement* FirstChildElement();
+        TiXmlElement* FirstChildElement() {
+                return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement() );
+        }
 
         /// Convenience function to get through elements.
-        const TiXmlElement* FirstChildElement( const char * value ) const;
-        TiXmlElement* FirstChildElement( const char * value );
+        const TiXmlElement* FirstChildElement( const char * _value ) const;
+        TiXmlElement* FirstChildElement( const char * _value ) {
+                return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode* >(this))->FirstChildElement( _value ) );
+        }
 
     #ifdef TIXML_USE_STL
@@ -631 +689 @@
         */
         const TiXmlDocument* GetDocument() const;
-        TiXmlDocument* GetDocument();
+        TiXmlDocument* GetDocument() {
+                return const_cast< TiXmlDocument* >( (const_cast< const TiXmlNode* >(this))->GetDocument() );
+        }
 
         /// Returns true if this node has no children.
         bool NoChildren() const                                         { return !firstChild; }
 
-        const TiXmlDocument* ToDocument()       const           { return ( this && type == DOCUMENT ) ? (const TiXmlDocument*) this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
-        const TiXmlElement*  ToElement() const                  { return ( this && type == ELEMENT  ) ? (const TiXmlElement*)  this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
-        const TiXmlComment*  ToComment() const                  { return ( this && type == COMMENT  ) ? (const TiXmlComment*)  this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
-        const TiXmlUnknown*  ToUnknown() const                  { return ( this && type == UNKNOWN  ) ? (const TiXmlUnknown*)  this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
-        const TiXmlText*           ToText()    const            { return ( this && type == TEXT     ) ? (const TiXmlText*)     this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
-        const TiXmlDeclaration* ToDeclaration() const   { return ( this && type == DECLARATION ) ? (const TiXmlDeclaration*) this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
-
-        TiXmlDocument* ToDocument()                     { return ( this && type == DOCUMENT ) ? (TiXmlDocument*) this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
-        TiXmlElement*  ToElement()                      { return ( this && type == ELEMENT  ) ? (TiXmlElement*)  this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
-        TiXmlComment*  ToComment()                      { return ( this && type == COMMENT  ) ? (TiXmlComment*)  this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
-        TiXmlUnknown*  ToUnknown()                      { return ( this && type == UNKNOWN  ) ? (TiXmlUnknown*)  this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
-        TiXmlText*         ToText()                     { return ( this && type == TEXT     ) ? (TiXmlText*)     this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
-        TiXmlDeclaration* ToDeclaration()       { return ( this && type == DECLARATION ) ? (TiXmlDeclaration*) this : 0; } ///< Cast to a more defined type. Will return null not of the requested type.
+        virtual const TiXmlDocument*    ToDocument()    const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
+        virtual const TiXmlElement*     ToElement()     const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
+        virtual const TiXmlComment*     ToComment()     const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
+        virtual const TiXmlUnknown*     ToUnknown()     const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
+        virtual const TiXmlText*        ToText()        const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
+        virtual const TiXmlDeclaration* ToDeclaration() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
+
+        virtual TiXmlDocument*          ToDocument()    { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
+        virtual TiXmlElement*           ToElement()         { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
+        virtual TiXmlComment*           ToComment()     { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
+        virtual TiXmlUnknown*           ToUnknown()         { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
+        virtual TiXmlText*                  ToText()        { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
+        virtual TiXmlDeclaration*       ToDeclaration() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
 
         /** Create an exact duplicate of this node and return it. The memory must be deleted
-                by the caller.
+                by the caller. 
         */
         virtual TiXmlNode* Clone() const = 0;
+
+        /** Accept a hierchical visit the nodes in the TinyXML DOM. Every node in the 
+                XML tree will be conditionally visited and the host will be called back
+                via the TiXmlVisitor interface.
+
+                This is essentially a SAX interface for TinyXML. (Note however it doesn't re-parse
+                the XML for the callbacks, so the performance of TinyXML is unchanged by using this
+                interface versus any other.)
+
+                The interface has been based on ideas from:
+
+                - http://www.saxproject.org/
+                - http://c2.com/cgi/wiki?HierarchicalVisitorPattern 
+
+                Which are both good references for "visiting".
+
+                An example of using Accept():
+                @verbatim
+                TiXmlPrinter printer;
+                tinyxmlDoc.Accept( &printer );
+                const char* xmlcstr = printer.CStr();
+                @endverbatim
+        */
+        virtual bool Accept( TiXmlVisitor* visitor ) const = 0;
 
 protected:
@@ -664 +748 @@
         #ifdef TIXML_USE_STL
             // The real work of the input operator.
-            virtual void StreamIn( TIXML_ISTREAM* in, TIXML_STRING* tag ) = 0;
+        virtual void StreamIn( std::istream* in, TIXML_STRING* tag ) = 0;
         #endif
 
@@ -726 +810 @@
         }
 
-        const char*             Name()  const           { return name.c_str (); }               ///< Return the name of this attribute.
-        const char*             Value() const           { return value.c_str (); }              ///< Return the value of this attribute.
+        const char*             Name()  const           { return name.c_str(); }                ///< Return the name of this attribute.
+        const char*             Value() const           { return value.c_str(); }               ///< Return the value of this attribute.
+        #ifdef TIXML_USE_STL
+        const std::string& ValueStr() const     { return value; }                               ///< Return the value of this attribute.
+        #endif
         int                             IntValue() const;                                                                       ///< Return the value of this attribute, converted to an integer.
         double                  DoubleValue() const;                                                            ///< Return the value of this attribute, converted to a double.
 
+        // Get the tinyxml string representation
+        const TIXML_STRING& NameTStr() const { return name; }
+
         /** QueryIntValue examines the value string. It is an alternative to the
                 IntValue() method with richer error checking.
-                If the value is an integer, it is stored in 'value' and
+                If the value is an integer, it is stored in 'value' and 
                 the call returns TIXML_SUCCESS. If it is not
                 an integer, it returns TIXML_WRONG_TYPE.
@@ -752 +842 @@
     #ifdef TIXML_USE_STL
         /// STL std::string form.
-        void SetName( const std::string& _name )
-        {
-                StringToBuffer buf( _name );
-                SetName ( buf.buffer ? buf.buffer : "error" );
-        }
-        /// STL std::string form.
-        void SetValue( const std::string& _value )
-        {
-                StringToBuffer buf( _value );
-                SetValue( buf.buffer ? buf.buffer : "error" );
-        }
+        void SetName( const std::string& _name )        { name = _name; }       
+        /// STL std::string form.       
+        void SetValue( const std::string& _value )      { value = _value; }
         #endif
 
         /// Get the next sibling attribute in the DOM. Returns null at end.
         const TiXmlAttribute* Next() const;
-        TiXmlAttribute* Next();
+        TiXmlAttribute* Next() {
+                return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Next() ); 
+        }
+
         /// Get the previous sibling attribute in the DOM. Returns null at beginning.
         const TiXmlAttribute* Previous() const;
-        TiXmlAttribute* Previous();
+        TiXmlAttribute* Previous() {
+                return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttribute* >(this))->Previous() ); 
+        }
 
         bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; }
@@ -782 +869 @@
 
         // Prints this Attribute to a FILE stream.
-        virtual void Print( FILE* cfile, int depth ) const;
-
-        virtual void StreamOut( TIXML_OSTREAM * out ) const;
+        virtual void Print( FILE* cfile, int depth ) const {
+                Print( cfile, depth, 0 );
+        }
+        void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;
+
         // [internal use]
         // Set the document pointer so the attribute can report errors.
@@ -803 +892 @@
 /*      A class used to manage a group of attributes.
         It is only used internally, both by the ELEMENT and the DECLARATION.
-
+        
         The set can be changed transparent to the Element and Declaration
         classes that use it, but NOT transparent to the Attribute
@@ -827 +916 @@
         TiXmlAttribute* Last()                                  { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
 
-        const TiXmlAttribute*   Find( const char * name ) const;
-        TiXmlAttribute* Find( const char * name );
+        const TiXmlAttribute*   Find( const char* _name ) const;
+        TiXmlAttribute* Find( const char* _name ) {
+                return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) );
+        }
+        #ifdef TIXML_USE_STL
+        const TiXmlAttribute*   Find( const std::string& _name ) const;
+        TiXmlAttribute* Find( const std::string& _name ) {
+                return const_cast< TiXmlAttribute* >( (const_cast< const TiXmlAttributeSet* >(this))->Find( _name ) );
+        }
+
+        #endif
 
 private:
@@ -884 +982 @@
         /** QueryIntAttribute examines the attribute - it is an alternative to the
                 Attribute() method with richer error checking.
-                If the attribute is an integer, it is stored in 'value' and
+                If the attribute is an integer, it is stored in 'value' and 
                 the call returns TIXML_SUCCESS. If it is not
                 an integer, it returns TIXML_WRONG_TYPE. If the attribute
                 does not exist, then TIXML_NO_ATTRIBUTE is returned.
-        */
+        */      
         int QueryIntAttribute( const char* name, int* _value ) const;
         /// QueryDoubleAttribute examines the attribute - see QueryIntAttribute().
@@ -902 +1000 @@
         }
 
+    #ifdef TIXML_USE_STL
+        /** Template form of the attribute query which will try to read the
+                attribute into the specified type. Very easy, very powerful, but
+                be careful to make sure to call this with the correct type.
+                
+                NOTE: This method doesn't work correctly for 'string' types.
+
+                @return TIXML_SUCCESS, TIXML_WRONG_TYPE, or TIXML_NO_ATTRIBUTE
+        */
+        template< typename T > int QueryValueAttribute( const std::string& name, T* outValue ) const
+        {
+                const TiXmlAttribute* node = attributeSet.Find( name );
+                if ( !node )
+                        return TIXML_NO_ATTRIBUTE;
+
+                std::stringstream sstream( node->ValueStr() );
+                sstream >> *outValue;
+                if ( !sstream.fail() )
+                        return TIXML_SUCCESS;
+                return TIXML_WRONG_TYPE;
+        }
+        /*
+         This is - in theory - a bug fix for "QueryValueAtribute returns truncated std::string"
+         but template specialization is hard to get working cross-compiler. Leaving the bug for now.
+         
+        // The above will fail for std::string because the space character is used as a seperator.
+        // Specialize for strings. Bug [ 1695429 ] QueryValueAtribute returns truncated std::string
+        template<> int QueryValueAttribute( const std::string& name, std::string* outValue ) const
+        {
+                const TiXmlAttribute* node = attributeSet.Find( name );
+                if ( !node )
+                        return TIXML_NO_ATTRIBUTE;
+                *outValue = node->ValueStr();
+                return TIXML_SUCCESS;
+        }
+        */
+        #endif
+
         /** Sets an attribute of name to a given value. The attribute
                 will be created if it does not exist, or changed if it does.
@@ -908 +1044 @@
 
     #ifdef TIXML_USE_STL
-        const char* Attribute( const std::string& name ) const                          { return Attribute( name.c_str() ); }
-        const char* Attribute( const std::string& name, int* i ) const          { return Attribute( name.c_str(), i ); }
-        const char* Attribute( const std::string& name, double* d ) const       { return Attribute( name.c_str(), d ); }
-        int QueryIntAttribute( const std::string& name, int* _value ) const     { return QueryIntAttribute( name.c_str(), _value ); }
-        int QueryDoubleAttribute( const std::string& name, double* _value ) const { return QueryDoubleAttribute( name.c_str(), _value ); }
+        const std::string* Attribute( const std::string& name ) const;
+        const std::string* Attribute( const std::string& name, int* i ) const;
+        const std::string* Attribute( const std::string& name, double* d ) const;
+        int QueryIntAttribute( const std::string& name, int* _value ) const;
+        int QueryDoubleAttribute( const std::string& name, double* _value ) const;
 
         /// STL std::string form.
-        void SetAttribute( const std::string& name, const std::string& _value )
-        {
-                StringToBuffer n( name );
-                StringToBuffer v( _value );
-                if ( n.buffer && v.buffer )
-                        SetAttribute (n.buffer, v.buffer );
-        }
+        void SetAttribute( const std::string& name, const std::string& _value );
         ///< STL std::string form.
-        void SetAttribute( const std::string& name, int _value )
-        {
-                StringToBuffer n( name );
-                if ( n.buffer )
-                        SetAttribute (n.buffer, _value);
-        }
+        void SetAttribute( const std::string& name, int _value );
         #endif
 
@@ -956 +1081 @@
                 and concise, GetText() is limited compared to getting the TiXmlText child
                 and accessing it directly.
-
+        
                 If the first child of 'this' is a TiXmlText, the GetText()
                 returns the character string of the Text node, else null is returned.
@@ -966 +1091 @@
                 @endverbatim
 
-                'str' will be a pointer to "This is text".
-
+                'str' will be a pointer to "This is text". 
+                
                 Note that this function can be misleading. If the element foo was created from
                 this XML:
                 @verbatim
-                <foo><b>This is text</b></foo>
+                <foo><b>This is text</b></foo> 
                 @endverbatim
 
@@ -977 +1102 @@
                 another element. From this XML:
                 @verbatim
-                <foo>This is <b>text</b></foo>
+                <foo>This is <b>text</b></foo> 
                 @endverbatim
                 GetText() will return "This is ".
 
-                WARNING: GetText() accesses a child node - don't become confused with the
-                                 similarly named TiXmlHandle::Text() and TiXmlNode::ToText() which are
+                WARNING: GetText() accesses a child node - don't become confused with the 
+                                 similarly named TiXmlHandle::Text() and TiXmlNode::ToText() which are 
                                  safe type casts on the referenced node.
         */
@@ -997 +1122 @@
         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
 
+        virtual const TiXmlElement*     ToElement()     const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+        virtual TiXmlElement*           ToElement()               { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+
+        /** Walk the XML tree visiting this node and all of its children. 
+        */
+        virtual bool Accept( TiXmlVisitor* visitor ) const;
+
 protected:
 
@@ -1004 +1136 @@
         // Used to be public [internal use]
         #ifdef TIXML_USE_STL
-            virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
-        #endif
-        virtual void StreamOut( TIXML_OSTREAM * out ) const;
-
+        virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
+        #endif
         /*      [internal use]
                 Reads the "value" of the element -- another element, or text.
@@ -1027 +1157 @@
         /// Constructs an empty comment.
         TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {}
+        /// Construct a comment from text.
+        TiXmlComment( const char* _value ) : TiXmlNode( TiXmlNode::COMMENT ) {
+                SetValue( _value );
+        }
         TiXmlComment( const TiXmlComment& );
         void operator=( const TiXmlComment& base );
@@ -1034 +1168 @@
         /// Returns a copy of this Comment.
         virtual TiXmlNode* Clone() const;
-        /// Write this Comment to a FILE stream.
+        // Write this Comment to a FILE stream.
         virtual void Print( FILE* cfile, int depth ) const;
 
@@ -1042 +1176 @@
         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
 
+        virtual const TiXmlComment*  ToComment() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+        virtual TiXmlComment*  ToComment() { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+
+        /** Walk the XML tree visiting this node and all of its children. 
+        */
+        virtual bool Accept( TiXmlVisitor* visitor ) const;
+
 protected:
         void CopyTo( TiXmlComment* target ) const;
@@ -1047 +1188 @@
         // used to be public
         #ifdef TIXML_USE_STL
-            virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
-        #endif
-        virtual void StreamOut( TIXML_OSTREAM * out ) const;
+        virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
+        #endif
+//      virtual void StreamOut( TIXML_OSTREAM * out ) const;
 
 private:
@@ -1056 +1197 @@
 
 
-/** XML text. A text node can have 2 ways to output the next. "normal" output
+/** XML text. A text node can have 2 ways to output the next. "normal" output 
         and CDATA. It will default to the mode it was parsed from the XML file and
-        you generally want to leave it alone, but you can change the output mode with
+        you generally want to leave it alone, but you can change the output mode with 
         SetCDATA() and query it with CDATA().
 */
@@ -1065 +1206 @@
         friend class TiXmlElement;
 public:
-        /** Constructor for text element. By default, it is treated as
+        /** Constructor for text element. By default, it is treated as 
                 normal, encoded text. If you want it be output as a CDATA text
                 element, set the parameter _cdata to 'true'
@@ -1088 +1229 @@
         void operator=( const TiXmlText& base )                                                         { base.CopyTo( this ); }
 
-        /// Write this text object to a FILE stream.
+        // Write this text object to a FILE stream.
         virtual void Print( FILE* cfile, int depth ) const;
 
         /// Queries whether this represents text using a CDATA section.
-        bool CDATA()                                    { return cdata; }
+        bool CDATA() const                              { return cdata; }
         /// Turns on or off a CDATA representation of text.
         void SetCDATA( bool _cdata )    { cdata = _cdata; }
 
         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
+
+        virtual const TiXmlText* ToText() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+        virtual TiXmlText*       ToText()       { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+
+        /** Walk the XML tree visiting this node and all of its children. 
+        */
+        virtual bool Accept( TiXmlVisitor* content ) const;
 
 protected :
@@ -1103 +1251 @@
         void CopyTo( TiXmlText* target ) const;
 
-        virtual void StreamOut ( TIXML_OSTREAM * out ) const;
         bool Blank() const;     // returns true if all white space and new lines
         // [internal use]
         #ifdef TIXML_USE_STL
-            virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
+        virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
         #endif
 
@@ -1160 +1307 @@
         /// Creates a copy of this Declaration and returns it.
         virtual TiXmlNode* Clone() const;
-        /// Print this declaration to a FILE stream.
-        virtual void Print( FILE* cfile, int depth ) const;
+        // Print this declaration to a FILE stream.
+        virtual void Print( FILE* cfile, int depth, TIXML_STRING* str ) const;
+        virtual void Print( FILE* cfile, int depth ) const {
+                Print( cfile, depth, 0 );
+        }
 
         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
+
+        virtual const TiXmlDeclaration* ToDeclaration() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+        virtual TiXmlDeclaration*       ToDeclaration()       { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+
+        /** Walk the XML tree visiting this node and all of its children. 
+        */
+        virtual bool Accept( TiXmlVisitor* visitor ) const;
 
 protected:
@@ -1169 +1326 @@
         // used to be public
         #ifdef TIXML_USE_STL
-            virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
-        #endif
-        virtual void StreamOut ( TIXML_OSTREAM * out) const;
+        virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
+        #endif
 
 private:
@@ -1199 +1355 @@
         /// Creates a copy of this Unknown and returns it.
         virtual TiXmlNode* Clone() const;
-        /// Print this Unknown to a FILE stream.
+        // Print this Unknown to a FILE stream.
         virtual void Print( FILE* cfile, int depth ) const;
 
         virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
+
+        virtual const TiXmlUnknown*     ToUnknown()     const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+        virtual TiXmlUnknown*           ToUnknown()         { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+
+        /** Walk the XML tree visiting this node and all of its children. 
+        */
+        virtual bool Accept( TiXmlVisitor* content ) const;
 
 protected:
@@ -1208 +1371 @@
 
         #ifdef TIXML_USE_STL
-            virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
-        #endif
-        virtual void StreamOut ( TIXML_OSTREAM * out ) const;
+        virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
+        #endif
 
 private:
@@ -1250 +1412 @@
         /// Save a file using the given filename. Returns true if successful.
         bool SaveFile( const char * filename ) const;
+        /** Load a file using the given FILE*. Returns true if successful. Note that this method
+                doesn't stream - the entire object pointed at by the FILE*
+                will be interpreted as an XML file. TinyXML doesn't stream in XML from the current
+                file location. Streaming may be added in the future.
+        */
+        bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
+        /// Save a file using the given FILE*. Returns true if successful.
+        bool SaveFile( FILE* ) const;
 
         #ifdef TIXML_USE_STL
         bool LoadFile( const std::string& filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING )                   ///< STL std::string version.
         {
-                StringToBuffer f( filename );
-                return ( f.buffer && LoadFile( f.buffer, encoding ));
+//              StringToBuffer f( filename );
+//              return ( f.buffer && LoadFile( f.buffer, encoding ));
+                return LoadFile( filename.c_str(), encoding );
         }
         bool SaveFile( const std::string& filename ) const              ///< STL std::string version.
         {
-                StringToBuffer f( filename );
-                return ( f.buffer && SaveFile( f.buffer ));
+//              StringToBuffer f( filename );
+//              return ( f.buffer && SaveFile( f.buffer ));
+                return SaveFile( filename.c_str() );
         }
         #endif
@@ -1281 +1453 @@
                 - The ErrorDesc() method will return the name of the error. (very useful)
                 - The ErrorRow() and ErrorCol() will return the location of the error (if known)
-        */
+        */      
         bool Error() const                                              { return error; }
 
@@ -1292 +1464 @@
         int ErrorId()   const                           { return errorId; }
 
-        /** Returns the location (if known) of the error. The first column is column 1,
+        /** Returns the location (if known) of the error. The first column is column 1, 
                 and the first row is row 1. A value of 0 means the row and column wasn't applicable
                 (memory errors, for example, have no row/column) or the parser lost the error. (An
@@ -1299 +1471 @@
                 @sa SetTabSize, Row, Column
         */
-        int ErrorRow()  { return errorLocation.row+1; }
-        int ErrorCol()  { return errorLocation.col+1; } ///< The column where the error occured. See ErrorRow()
+        int ErrorRow() const    { return errorLocation.row+1; }
+        int ErrorCol() const    { return errorLocation.col+1; } ///< The column where the error occured. See ErrorRow()
 
         /** SetTabSize() allows the error reporting functions (ErrorRow() and ErrorCol())
                 to report the correct values for row and column. It does not change the output
                 or input in any way.
-
+                
                 By calling this method, with a tab size
                 greater than 0, the row and column of each node and attribute is stored
@@ -1333 +1505 @@
                 state is automatically cleared if you Parse a new XML block.
         */
-        void ClearError()                                               {       error = false;
-                                                                                                errorId = 0;
-                                                                                                errorDesc = "";
-                                                                                                errorLocation.row = errorLocation.col = 0;
-                                                                                                //errorLocation.last = 0;
+        void ClearError()                                               {       error = false; 
+                                                                                                errorId = 0; 
+                                                                                                errorDesc = ""; 
+                                                                                                errorLocation.row = errorLocation.col = 0; 
+                                                                                                //errorLocation.last = 0; 
                                                                                         }
 
-        /** Dump the document to standard out. */
+        /** Write the document to standard out using formatted printing ("pretty print"). */
         void Print() const                                              { Print( stdout, 0 ); }
+
+        /* Write the document to a string using formatted printing ("pretty print"). This
+                will allocate a character array (new char[]) and return it as a pointer. The
+                calling code pust call delete[] on the return char* to avoid a memory leak.
+        */
+        //char* PrintToMemory() const; 
 
         /// Print this Document to a FILE stream.
@@ -1348 +1526 @@
         void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );
 
+        virtual const TiXmlDocument*    ToDocument()    const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+        virtual TiXmlDocument*          ToDocument()          { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
+
+        /** Walk the XML tree visiting this node and all of its children. 
+        */
+        virtual bool Accept( TiXmlVisitor* content ) const;
+
 protected :
-        virtual void StreamOut ( TIXML_OSTREAM * out) const;
         // [internal use]
         virtual TiXmlNode* Clone() const;
         #ifdef TIXML_USE_STL
-            virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
+        virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
         #endif
 
@@ -1383 +1567 @@
         @endverbatim
 
-        Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
+        Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very 
         easy to write a *lot* of code that looks like:
 
@@ -1403 +1587 @@
 
         And that doesn't even cover "else" cases. TiXmlHandle addresses the verbosity
-        of such code. A TiXmlHandle checks for null     pointers so it is perfectly safe
+        of such code. A TiXmlHandle checks for null     pointers so it is perfectly safe 
         and correct to use:
 
         @verbatim
         TiXmlHandle docHandle( &document );
-        TiXmlElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", 1 ).Element();
+        TiXmlElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", 1 ).ToElement();
         if ( child2 )
         {
@@ -1424 +1608 @@
 
         @verbatim
-        int i=0;
+        int i=0; 
         while ( true )
         {
-                TiXmlElement* child = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", i ).Element();
+                TiXmlElement* child = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", i ).ToElement();
                 if ( !child )
                         break;
@@ -1435 +1619 @@
         @endverbatim
 
-        It seems reasonable, but it is in fact two embedded while loops. The Child method is
-        a linear walk to find the element, so this code would iterate much more than it needs
+        It seems reasonable, but it is in fact two embedded while loops. The Child method is 
+        a linear walk to find the element, so this code would iterate much more than it needs 
         to. Instead, prefer:
 
         @verbatim
-        TiXmlElement* child = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild( "Child" ).Element();
+        TiXmlElement* child = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild( "Child" ).ToElement();
 
         for( child; child; child=child->NextSiblingElement() )
@@ -1466 +1650 @@
         TiXmlHandle FirstChildElement( const char * value ) const;
 
-        /** Return a handle to the "index" child with the given name.
+        /** Return a handle to the "index" child with the given name. 
                 The first child is 0, the second 1, etc.
         */
         TiXmlHandle Child( const char* value, int index ) const;
-        /** Return a handle to the "index" child.
+        /** Return a handle to the "index" child. 
                 The first child is 0, the second 1, etc.
         */
         TiXmlHandle Child( int index ) const;
-        /** Return a handle to the "index" child element with the given name.
+        /** Return a handle to the "index" child element with the given name. 
                 The first child element is 0, the second 1, etc. Note that only TiXmlElements
                 are indexed: other types are not counted.
         */
         TiXmlHandle ChildElement( const char* value, int index ) const;
-        /** Return a handle to the "index" child element.
+        /** Return a handle to the "index" child element. 
                 The first child element is 0, the second 1, etc. Note that only TiXmlElements
                 are indexed: other types are not counted.
@@ -1493 +1677 @@
         #endif
 
-        /// Return the handle as a TiXmlNode. This may return null.
-        TiXmlNode* Node() const                 { return node; }
-        /// Return the handle as a TiXmlElement. This may return null.
-        TiXmlElement* Element() const   { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
-        /// Return the handle as a TiXmlText. This may return null.
-        TiXmlText* Text() const                 { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
-        /// Return the handle as a TiXmlUnknown. This may return null;
-        TiXmlUnknown* Unknown() const                   { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
+        /** Return the handle as a TiXmlNode. This may return null.
+        */
+        TiXmlNode* ToNode() const                       { return node; } 
+        /** Return the handle as a TiXmlElement. This may return null.
+        */
+        TiXmlElement* ToElement() const         { return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
+        /**     Return the handle as a TiXmlText. This may return null.
+        */
+        TiXmlText* ToText() const                       { return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
+        /** Return the handle as a TiXmlUnknown. This may return null.
+        */
+        TiXmlUnknown* ToUnknown() const         { return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
+
+        /** @deprecated use ToNode. 
+                Return the handle as a TiXmlNode. This may return null.
+        */
+        TiXmlNode* Node() const                 { return ToNode(); } 
+        /** @deprecated use ToElement. 
+                Return the handle as a TiXmlElement. This may return null.
+        */
+        TiXmlElement* Element() const   { return ToElement(); }
+        /**     @deprecated use ToText()
+                Return the handle as a TiXmlText. This may return null.
+        */
+        TiXmlText* Text() const                 { return ToText(); }
+        /** @deprecated use ToUnknown()
+                Return the handle as a TiXmlUnknown. This may return null.
+        */
+        TiXmlUnknown* Unknown() const   { return ToUnknown(); }
 
 private:
@@ -1506 +1711 @@
 };
 
+
+/** Print to memory functionality. The TiXmlPrinter is useful when you need to:
+
+        -# Print to memory (especially in non-STL mode)
+        -# Control formatting (line endings, etc.)
+
+        When constructed, the TiXmlPrinter is in its default "pretty printing" mode.
+        Before calling Accept() you can call methods to control the printing
+        of the XML document. After TiXmlNode::Accept() is called, the printed document can
+        be accessed via the CStr(), Str(), and Size() methods.
+
+        TiXmlPrinter uses the Visitor API.
+        @verbatim
+        TiXmlPrinter printer;
+        printer.SetIndent( "\t" );
+
+        doc.Accept( &printer );
+        fprintf( stdout, "%s", printer.CStr() );
+        @endverbatim
+*/
+class TiXmlPrinter : public TiXmlVisitor
+{
+public:
+        TiXmlPrinter() : depth( 0 ), simpleTextPrint( false ),
+                                         buffer(), indent( "    " ), lineBreak( "\n" ) {}
+
+        virtual bool VisitEnter( const TiXmlDocument& doc );
+        virtual bool VisitExit( const TiXmlDocument& doc );
+
+        virtual bool VisitEnter( const TiXmlElement& element, const TiXmlAttribute* firstAttribute );
+        virtual bool VisitExit( const TiXmlElement& element );
+
+        virtual bool Visit( const TiXmlDeclaration& declaration );
+        virtual bool Visit( const TiXmlText& text );
+        virtual bool Visit( const TiXmlComment& comment );
+        virtual bool Visit( const TiXmlUnknown& unknown );
+
+        /** Set the indent characters for printing. By default 4 spaces
+                but tab (\t) is also useful, or null/empty string for no indentation.
+        */
+        void SetIndent( const char* _indent )                   { indent = _indent ? _indent : "" ; }
+        /// Query the indention string.
+        const char* Indent()                                                    { return indent.c_str(); }
+        /** Set the line breaking string. By default set to newline (\n). 
+                Some operating systems prefer other characters, or can be
+                set to the null/empty string for no indenation.
+        */
+        void SetLineBreak( const char* _lineBreak )             { lineBreak = _lineBreak ? _lineBreak : ""; }
+        /// Query the current line breaking string.
+        const char* LineBreak()                                                 { return lineBreak.c_str(); }
+
+        /** Switch over to "stream printing" which is the most dense formatting without 
+                linebreaks. Common when the XML is needed for network transmission.
+        */
+        void SetStreamPrinting()                                                { indent = "";
+                                                                                                          lineBreak = "";
+                                                                                                        }       
+        /// Return the result.
+        const char* CStr()                                                              { return buffer.c_str(); }
+        /// Return the length of the result string.
+        size_t Size()                                                                   { return buffer.size(); }
+
+        #ifdef TIXML_USE_STL
+        /// Return the result.
+        const std::string& Str()                                                { return buffer; }
+        #endif
+
+private:
+        void DoIndent() {
+                for( int i=0; i<depth; ++i )
+                        buffer += indent;
+        }
+        void DoLineBreak() {
+                buffer += lineBreak;
+        }
+
+        int depth;
+        bool simpleTextPrint;
+        TIXML_STRING buffer;
+        TIXML_STRING indent;
+        TIXML_STRING lineBreak;
+};
+
+
 #ifdef _MSC_VER
 #pragma warning( pop )

code/branches/FICN/src/tinyxml/tinyxmlerror.cc

@@ -1 +1 @@
 /*
 www.sourceforge.net/projects/tinyxml
-Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
+Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)
 
-This software is provided 'as-is', without any express or implied 
-warranty. In no event will the authors be held liable for any 
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
 damages arising from the use of this software.
 
-Permission is granted to anyone to use this software for any 
-purpose, including commercial applications, and to alter it and 
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
 redistribute it freely, subject to the following restrictions:
 
@@ -50 +50 @@
         "Error null (0) or unexpected EOF found in input stream.",
         "Error parsing CDATA.",
+        "Error when TiXmlDocument added to document, because TiXmlDocument can only be at the root.",
 };

code/branches/FICN/src/tinyxml/tinyxmlparser.cc

@@ -3 +3 @@
 Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
 
-This software is provided 'as-is', without any express or implied 
-warranty. In no event will the authors be held liable for any 
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
 damages arising from the use of this software.
 
-Permission is granted to anyone to use this software for any 
-purpose, including commercial applications, and to alter it and 
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
 redistribute it freely, subject to the following restrictions:
 
-1. The origin of this software must not be misrepresented; you must 
+1. The origin of this software must not be misrepresented; you must
 not claim that you wrote the original software. If you use this
 software in a product, an acknowledgment in the product documentation
 would be appreciated but is not required.
 
-2. Altered source versions must be plainly marked as such, and 
+2. Altered source versions must be plainly marked as such, and
 must not be misrepresented as being the original software.
 
-3. This notice may not be removed or altered from any source 
+3. This notice may not be removed or altered from any source
 distribution.
 */
 
-#include "tinyxml.h"
 #include <ctype.h>
 #include <stddef.h>
 
+#include "tinyxml.h"
+
 //#define DEBUG_PARSER
+#if defined( DEBUG_PARSER )
+#       if defined( DEBUG ) && defined( _MSC_VER )
+#               include <windows.h>
+#               define TIXML_LOG OutputDebugString
+#       else
+#               define TIXML_LOG printf
+#       endif
+#endif
 
 // Note tha "PutString" hardcodes the same list. This
 // is less flexible than it appears. Changing the entries
-// or order will break putstring.       
-TiXmlBase::Entity TiXmlBase::entity[ NUM_ENTITY ] = 
+// or order will break putstring.
+TiXmlBase::Entity TiXmlBase::entity[ NUM_ENTITY ] =
 {
         { "&amp;",  5, '&' },
@@ -46 +55 @@
 // sequence from the lead byte. 1 placed for invalid sequences --
 // although the result will be junk, pass it through as much as possible.
-// Beware of the non-characters in UTF-8:       
+// Beware of the non-characters in UTF-8:
 //                              ef bb bf (Microsoft "lead bytes")
 //                              ef bf be
-//                              ef bf bf 
+//                              ef bf bf
 
 const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
@@ -55 +64 @@
 const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
 
-const int TiXmlBase::utf8ByteTable[256] = 
+const int TiXmlBase::utf8ByteTable[256] =
 {
         //      0       1       2       3       4       5       6       7       8       9       a       b       c       d       e       f
@@ -67 +76 @@
                 1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0x70 End of ASCII range
                 1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0x80 0x80 to 0xc1 invalid
-                1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0x90 
-                1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0xa0 
-                1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0xb0 
+                1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0x90
+                1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0xa0
+                1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0xb0
                 1,      1,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      // 0xc0 0xc2 to 0xdf 2 byte
                 2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      // 0xd0
@@ -83 +92 @@
         const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
 
-        if (input < 0x80) 
+        if (input < 0x80)
                 *length = 1;
         else if ( input < 0x800 )
@@ -97 +106 @@
 
         // Scary scary fall throughs.
-        switch (*length) 
+        switch (*length)
         {
                 case 4:
-                        --output; 
-                        *output = (char)((input | BYTE_MARK) & BYTE_MASK); 
+                        --output;
+                        *output = (char)((input | BYTE_MARK) & BYTE_MASK);
                         input >>= 6;
                 case 3:
-                        --output; 
-                        *output = (char)((input | BYTE_MARK) & BYTE_MASK); 
+                        --output;
+                        *output = (char)((input | BYTE_MARK) & BYTE_MASK);
                         input >>= 6;
                 case 2:
-                        --output; 
-                        *output = (char)((input | BYTE_MARK) & BYTE_MASK); 
+                        --output;
+                        *output = (char)((input | BYTE_MARK) & BYTE_MASK);
                         input >>= 6;
                 case 1:
-                        --output; 
+                        --output;
                         *output = (char)(input | FIRST_BYTE_MARK[*length]);
         }
@@ -122 +131 @@
         // This will only work for low-ascii, everything else is assumed to be a valid
         // letter. I'm not sure this is the best approach, but it is quite tricky trying
-        // to figure out alhabetical vs. not across encoding. So take a very 
+        // to figure out alhabetical vs. not across encoding. So take a very
         // conservative approach.
 
@@ -143 +152 @@
         // This will only work for low-ascii, everything else is assumed to be a valid
         // letter. I'm not sure this is the best approach, but it is quite tricky trying
-        // to figure out alhabetical vs. not across encoding. So take a very 
+        // to figure out alhabetical vs. not across encoding. So take a very
         // conservative approach.
 
@@ -216 +225 @@
                                 // bump down to the next line
                                 ++row;
-                                col = 0;                                
+                                col = 0;
                                 // Eat the character
                                 ++p;
@@ -258 +267 @@
                                                 // 0-width spaces.
                                                 if ( *(pU+1)==TIXML_UTF_LEAD_1 && *(pU+2)==TIXML_UTF_LEAD_2 )
-                                                        p += 3; 
+                                                        p += 3;
                                                 else if ( *(pU+1)==0xbfU && *(pU+2)==0xbeU )
-                                                        p += 3; 
+                                                        p += 3;
                                                 else if ( *(pU+1)==0xbfU && *(pU+2)==0xbfU )
-                                                        p += 3; 
+                                                        p += 3;
                                                 else
                                                         { p +=3; ++col; }       // A normal character.
@@ -278 +287 @@
                                 {
                                         // Eat the 1 to 4 byte utf8 character.
-                                        int step = TiXmlBase::utf8ByteTable[*((unsigned char*)p)];
+                                        int step = TiXmlBase::utf8ByteTable[*((const unsigned char*)p)];
                                         if ( step == 0 )
                                                 step = 1;               // Error case from bad encoding, but handle gracefully.
@@ -314 +323 @@
                 {
                         const unsigned char* pU = (const unsigned char*)p;
-                        
+
                         // Skip the stupid Microsoft UTF-8 Byte order marks
                         if (    *(pU+0)==TIXML_UTF_LEAD_0
-                                 && *(pU+1)==TIXML_UTF_LEAD_1 
+                                 && *(pU+1)==TIXML_UTF_LEAD_1
                                  && *(pU+2)==TIXML_UTF_LEAD_2 )
                         {
@@ -354 +363 @@
 
 #ifdef TIXML_USE_STL
-/*static*/ bool TiXmlBase::StreamWhiteSpace( TIXML_ISTREAM * in, TIXML_STRING * tag )
+/*static*/ bool TiXmlBase::StreamWhiteSpace( std::istream * in, TIXML_STRING * tag )
 {
         for( ;; )
@@ -369 +378 @@
 }
 
-/*static*/ bool TiXmlBase::StreamTo( TIXML_ISTREAM * in, int character, TIXML_STRING * tag )
+/*static*/ bool TiXmlBase::StreamTo( std::istream * in, int character, TIXML_STRING * tag )
 {
         //assert( character > 0 && character < 128 );   // else it won't work in utf-8
@@ -387 +396 @@
 #endif
 
+// One of TinyXML's more performance demanding functions. Try to keep the memory overhead down. The
+// "assign" optimization removes over 10% of the execution time.
+//
 const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncoding encoding )
 {
+        // Oddly, not supported on some comilers,
+        //name->clear();
+        // So use this:
         *name = "";
         assert( p );
@@ -399 +414 @@
         // hyphens, or colons. (Colons are valid ony for namespaces,
         // but tinyxml can't tell namespaces from names.)
-        if (    p && *p 
+        if (    p && *p
                  && ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) )
         {
+                const char* start = p;
                 while(          p && *p
-                                &&      (               IsAlphaNum( (unsigned char ) *p, encoding ) 
+                                &&      (               IsAlphaNum( (unsigned char ) *p, encoding )
                                                  || *p == '_'
                                                  || *p == '-'
@@ -409 +425 @@
                                                  || *p == ':' ) )
                 {
-                        (*name) += *p;
+                        //(*name) += *p; // expensive
                         ++p;
+                }
+                if ( p-start > 0 ) {
+                        name->assign( start, p-start );
                 }
                 return p;
@@ -451 +470 @@
                                 else if ( *q >= 'A' && *q <= 'F' )
                                         ucs += mult * (*q - 'A' + 10 );
-                                else 
+                                else
                                         return 0;
                                 mult *= 16;
@@ -474 +493 @@
                                 if ( *q >= '0' && *q <= '9' )
                                         ucs += mult * (*q - '0');
-                                else 
+                                else
                                         return 0;
                                 mult *= 10;
@@ -507 +526 @@
         // So it wasn't an entity, its unrecognized, or something like that.
         *value = *p;    // Don't put back the last one, since we return it!
+        //*length = 1;  // Leave unrecognized entities - this doesn't really work.
+                                        // Just writes strange XML.
         return p+1;
 }
@@ -551 +572 @@
 }
 
-const char* TiXmlBase::ReadText(        const char* p, 
-                                                                        TIXML_STRING * text, 
-                                                                        bool trimWhiteSpace, 
-                                                                        const char* endTag, 
+const char* TiXmlBase::ReadText(        const char* p,
+                                                                        TIXML_STRING * text,
+                                                                        bool trimWhiteSpace,
+                                                                        const char* endTag,
                                                                         bool caseInsensitive,
                                                                         TiXmlEncoding encoding )
@@ -611 +632 @@
                 }
         }
-        return p + strlen( endTag );
+        if ( p )
+                p += strlen( endTag );
+        return p;
 }
 
 #ifdef TIXML_USE_STL
 
-void TiXmlDocument::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
+void TiXmlDocument::StreamIn( std::istream * in, TIXML_STRING * tag )
 {
         // The basic issue with a document is that we don't know what we're
@@ -625 +648 @@
         // sub-tag can orient itself.
 
-        if ( !StreamTo( in, '<', tag ) ) 
+        if ( !StreamTo( in, '<', tag ) )
         {
                 SetError( TIXML_ERROR_PARSING_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );
@@ -647 +670 @@
                 if ( in->good() )
                 {
-                        // We now have something we presume to be a node of 
+                        // We now have something we presume to be a node of
                         // some sort. Identify it, and call the node to
                         // continue streaming.
@@ -756 +779 @@
                         else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) )
                                 encoding = TIXML_ENCODING_UTF8; // incorrect, but be nice
-                        else 
+                        else
                                 encoding = TIXML_ENCODING_LEGACY;
                 }
@@ -774 +797 @@
 
 void TiXmlDocument::SetError( int err, const char* pError, TiXmlParsingData* data, TiXmlEncoding encoding )
-{       
+{
         // The first error in a chain is more accurate - don't set again!
         if ( error )
@@ -811 +834 @@
         }
 
-        // What is this thing? 
+        // What is this thing?
         // - Elements start with a letter or underscore, but xml is reserved.
         // - Comments: <!--
@@ -884 +907 @@
 #ifdef TIXML_USE_STL
 
-void TiXmlElement::StreamIn (TIXML_ISTREAM * in, TIXML_STRING * tag)
+void TiXmlElement::StreamIn (std::istream * in, TIXML_STRING * tag)
 {
         // We're called with some amount of pre-parsing. That is, some of "this"
@@ -899 +922 @@
                 }
                 (*tag) += (char) c ;
-                
+
                 if ( c == '>' )
                         break;
@@ -909 +932 @@
         // If not, identify and stream.
 
-        if (    tag->at( tag->length() - 1 ) == '>' 
+        if (    tag->at( tag->length() - 1 ) == '>'
                  && tag->at( tag->length() - 2 ) == '/' )
         {
@@ -919 +942 @@
                 // There is more. Could be:
                 //              text
+                //              cdata text (which looks like another node)
                 //              closing tag
                 //              another node.
@@ -926 +950 @@
 
                         // Do we have text?
-                        if ( in->good() && in->peek() != '<' ) 
+                        if ( in->good() && in->peek() != '<' )
                         {
                                 // Yep, text.
@@ -959 +983 @@
                                         return;
                                 }
-                                
+
                                 if ( c == '>' )
                                         break;
@@ -965 +989 @@
                                 *tag += (char) c;
                                 in->get();
+
+                                // Early out if we find the CDATA id.
+                                if ( c == '[' && tag->size() >= 9 )
+                                {
+                                        size_t len = tag->size();
+                                        const char* start = tag->c_str() + len - 9;
+                                        if ( strcmp( start, "<![CDATA[" ) == 0 ) {
+                                                assert( !closingTag );
+                                                break;
+                                        }
+                                }
 
                                 if ( !firstCharFound && c != '<' && !IsWhiteSpace( c ) )
@@ -1068 +1103 @@
                         if ( *p  != '>' )
                         {
-                                if ( document ) document->SetError( TIXML_ERROR_PARSING_EMPTY, p, data, encoding );             
+                                if ( document ) document->SetError( TIXML_ERROR_PARSING_EMPTY, p, data, encoding );
                                 return 0;
                         }
@@ -1080 +1115 @@
                         ++p;
                         p = ReadValue( p, data, encoding );             // Note this is an Element method, and will set the error if one happens.
-                        if ( !p || !*p )
+                        if ( !p || !*p ) {
+                                // We were looking for the end tag, but found nothing.
+                                // Fix for [ 1663758 ] Failure to report error on bad XML
+                                if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );
                                 return 0;
+                        }
 
                         // We should find the end tag now
@@ -1106 +1145 @@
 
                         attrib->SetDocument( document );
-                        const char* pErr = p;
+                        pErr = p;
                         p = attrib->Parse( p, data, encoding );
 
@@ -1117 +1156 @@
 
                         // Handle the strange case of double attributes:
+                        #ifdef TIXML_USE_STL
+                        TiXmlAttribute* node = attributeSet.Find( attrib->NameTStr() );
+                        #else
                         TiXmlAttribute* node = attributeSet.Find( attrib->Name() );
+                        #endif
                         if ( node )
                         {
@@ -1168 +1211 @@
                         else
                                 delete textNode;
-                } 
-                else 
+                }
+                else
                 {
                         // We hit a '<'
@@ -1185 +1228 @@
                                         p = node->Parse( p, data, encoding );
                                         LinkEndChild( node );
-                                }                               
+                                }
                                 else
                                 {
@@ -1199 +1242 @@
         {
                 if ( document ) document->SetError( TIXML_ERROR_READING_ELEMENT_VALUE, 0, 0, encoding );
-        }       
+        }
         return p;
 }
@@ -1205 +1248 @@
 
 #ifdef TIXML_USE_STL
-void TiXmlUnknown::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
+void TiXmlUnknown::StreamIn( std::istream * in, TIXML_STRING * tag )
 {
         while ( in->good() )
         {
-                int c = in->get();      
+                int c = in->get();
                 if ( c <= 0 )
                 {
@@ -1222 +1265 @@
                 {
                         // All is well.
-                        return;         
+                        return;
                 }
         }
@@ -1263 +1306 @@
 
 #ifdef TIXML_USE_STL
-void TiXmlComment::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
+void TiXmlComment::StreamIn( std::istream * in, TIXML_STRING * tag )
 {
         while ( in->good() )
         {
-                int c = in->get();      
+                int c = in->get();
                 if ( c <= 0 )
                 {
@@ -1278 +1321 @@
                 (*tag) += (char) c;
 
-                if ( c == '>' 
+                if ( c == '>'
                          && tag->at( tag->length() - 2 ) == '-'
                          && tag->at( tag->length() - 3 ) == '-' )
                 {
                         // All is well.
-                        return;         
+                        return;
                 }
         }
@@ -1311 +1354 @@
         }
         p += strlen( startTag );
-        p = ReadText( p, &value, false, endTag, false, encoding );
+
+        // [ 1475201 ] TinyXML parses entities in comments
+        // Oops - ReadText doesn't work, because we don't want to parse the entities.
+        // p = ReadText( p, &value, false, endTag, false, encoding );
+        //
+        // from the XML spec:
+        /*
+         [Definition: Comments may appear anywhere in a document outside other markup; in addition,
+                      they may appear within the document type declaration at places allowed by the grammar.
+                                  They are not part of the document's character data; an XML processor MAY, but need not,
+                                  make it possible for an application to retrieve the text of comments. For compatibility,
+                                  the string "--" (double-hyphen) MUST NOT occur within comments.] Parameter entity
+                                  references MUST NOT be recognized within comments.
+
+                                  An example of a comment:
+
+                                  <!-- declarations for <head> & <body> -->
+        */
+
+    value = "";
+        // Keep all the white space.
+        while ( p && *p && !StringEqual( p, endTag, false, encoding ) )
+        {
+                value.append( p, 1 );
+                ++p;
+        }
+        if ( p )
+                p += strlen( endTag );
+
         return p;
 }
@@ -1321 +1392 @@
         if ( !p || !*p ) return 0;
 
-        int tabsize = 4;
-        if ( document )
-                tabsize = document->TabSize();
+//      int tabsize = 4;
+//      if ( document )
+//              tabsize = document->TabSize();
 
         if ( data )
@@ -1352 +1423 @@
                 return 0;
         }
-        
+
         const char* end;
-
-        if ( *p == '\'' )
+        const char SINGLE_QUOTE = '\'';
+        const char DOUBLE_QUOTE = '\"';
+
+        if ( *p == SINGLE_QUOTE )
         {
                 ++p;
-                end = "\'";
+                end = "\'";             // single quote in string
                 p = ReadText( p, &value, false, end, false, encoding );
         }
-        else if ( *p == '"' )
+        else if ( *p == DOUBLE_QUOTE )
         {
                 ++p;
-                end = "\"";
+                end = "\"";             // double quote in string
                 p = ReadText( p, &value, false, end, false, encoding );
         }
@@ -1373 +1446 @@
                 // its best, even without them.
                 value = "";
-                while (    p && *p                                                                              // existence
+                while (    p && *p                                                                                      // existence
                                 && !IsWhiteSpace( *p ) && *p != '\n' && *p != '\r'      // whitespace
-                                && *p != '/' && *p != '>' )                                             // tag end
-                {
+                                && *p != '/' && *p != '>' )                                                     // tag end
+                {
+                        if ( *p == SINGLE_QUOTE || *p == DOUBLE_QUOTE ) {
+                                // [ 1451649 ] Attribute values with trailing quotes not handled correctly
+                                // We did not have an opening quote but seem to have a
+                                // closing one. Give up and throw an error.
+                                if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );
+                                return 0;
+                        }
                         value += *p;
                         ++p;
@@ -1385 +1465 @@
 
 #ifdef TIXML_USE_STL
-void TiXmlText::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
-{
-        if ( cdata )
-        {
-                int c = in->get();      
+void TiXmlText::StreamIn( std::istream * in, TIXML_STRING * tag )
+{
+        while ( in->good() )
+        {
+                int c = in->peek();
+                if ( !cdata && (c == '<' ) )
+                {
+                        return;
+                }
                 if ( c <= 0 )
                 {
@@ -1399 +1483 @@
 
                 (*tag) += (char) c;
-
-                if ( c == '>' 
-                         && tag->at( tag->length() - 2 ) == ']'
-                         && tag->at( tag->length() - 3 ) == ']' )
-                {
-                        // All is well.
-                        return;         
-                }
-        }
-        else
-        {
-                while ( in->good() )
-                {
-                        int c = in->peek();     
-                        if ( c == '<' )
+                in->get();      // "commits" the peek made above
+
+                if ( cdata && c == '>' && tag->size() >= 3 ) {
+                        size_t len = tag->size();
+                        if ( (*tag)[len-2] == ']' && (*tag)[len-3] == ']' ) {
+                                // terminator of cdata.
                                 return;
-                        if ( c <= 0 )
-                        {
-                                TiXmlDocument* document = GetDocument();
-                                if ( document )
-                                        document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );
-                                return;
-                        }
-
-                        (*tag) += (char) c;
-                        in->get();
+                        }
                 }
         }
@@ -1464 +1530 @@
                 }
 
-                TIXML_STRING dummy; 
+                TIXML_STRING dummy;
                 p = ReadText( p, &dummy, false, endTag, false, encoding );
                 return p;
@@ -1481 +1547 @@
 
 #ifdef TIXML_USE_STL
-void TiXmlDeclaration::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
+void TiXmlDeclaration::StreamIn( std::istream * in, TIXML_STRING * tag )
 {
         while ( in->good() )
@@ -1538 +1604 @@
                 {
                         TiXmlAttribute attrib;
-                        p = attrib.Parse( p, data, _encoding );         
+                        p = attrib.Parse( p, data, _encoding );
                         version = attrib.Value();
                 }
@@ -1544 +1610 @@
                 {
                         TiXmlAttribute attrib;
-                        p = attrib.Parse( p, data, _encoding );         
+                        p = attrib.Parse( p, data, _encoding );
                         encoding = attrib.Value();
                 }
@@ -1550 +1616 @@
                 {
                         TiXmlAttribute attrib;
-                        p = attrib.Parse( p, data, _encoding );         
+                        p = attrib.Parse( p, data, _encoding );
                         standalone = attrib.Value();
                 }