finish switching to _ for member vars
diff --git a/tinyxml2.cpp b/tinyxml2.cpp
index 8263796..b710b40 100755
--- a/tinyxml2.cpp
+++ b/tinyxml2.cpp
@@ -50,14 +50,14 @@
 

 #define DELETE_NODE( node )	{			\

         if ( node ) {						\

-            MemPool* pool = node->memPool;	\

+            MemPool* pool = node->_memPool;	\

             node->~XMLNode();				\

             pool->Free( node );				\

         }									\

     }

 #define DELETE_ATTRIBUTE( attrib ) {		\

         if ( attrib ) {							\

-            MemPool* pool = attrib->memPool;	\

+            MemPool* pool = attrib->_memPool;	\

             attrib->~XMLAttribute();			\

             pool->Free( attrib );				\

         }										\

@@ -527,35 +527,35 @@
 #pragma warning (pop)

 #endif

     if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {

-        returnNode = new (commentPool.Alloc()) XMLDeclaration( this );

-        returnNode->memPool = &commentPool;

+        returnNode = new (_commentPool.Alloc()) XMLDeclaration( this );

+        returnNode->_memPool = &_commentPool;

         p += xmlHeaderLen;

     }

     else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {

-        returnNode = new (commentPool.Alloc()) XMLComment( this );

-        returnNode->memPool = &commentPool;

+        returnNode = new (_commentPool.Alloc()) XMLComment( this );

+        returnNode->_memPool = &_commentPool;

         p += commentHeaderLen;

     }

     else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {

-        XMLText* text = new (textPool.Alloc()) XMLText( this );

+        XMLText* text = new (_textPool.Alloc()) XMLText( this );

         returnNode = text;

-        returnNode->memPool = &textPool;

+        returnNode->_memPool = &_textPool;

         p += cdataHeaderLen;

         text->SetCData( true );

     }

     else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {

-        returnNode = new (commentPool.Alloc()) XMLUnknown( this );

-        returnNode->memPool = &commentPool;

+        returnNode = new (_commentPool.Alloc()) XMLUnknown( this );

+        returnNode->_memPool = &_commentPool;

         p += dtdHeaderLen;

     }

     else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {

-        returnNode = new (elementPool.Alloc()) XMLElement( this );

-        returnNode->memPool = &elementPool;

+        returnNode = new (_elementPool.Alloc()) XMLElement( this );

+        returnNode->_memPool = &_elementPool;

         p += elementHeaderLen;

     }

     else {

-        returnNode = new (textPool.Alloc()) XMLText( this );

-        returnNode->memPool = &textPool;

+        returnNode = new (_textPool.Alloc()) XMLText( this );

+        returnNode->_memPool = &_textPool;

         p = start;	// Back it up, all the text counts.

     }

 

@@ -580,10 +580,10 @@
 // --------- XMLNode ----------- //

 

 XMLNode::XMLNode( XMLDocument* doc ) :

-    document( doc ),

-    parent( 0 ),

-    firstChild( 0 ), lastChild( 0 ),

-    prev( 0 ), next( 0 )

+    _document( doc ),

+    _parent( 0 ),

+    _firstChild( 0 ), _lastChild( 0 ),

+    _prev( 0 ), _next( 0 )

 {

 }

 

@@ -591,8 +591,8 @@
 XMLNode::~XMLNode()

 {

     DeleteChildren();

-    if ( parent ) {

-        parent->Unlink( this );

+    if ( _parent ) {

+        _parent->Unlink( this );

     }

 }

 

@@ -600,116 +600,116 @@
 void XMLNode::SetValue( const char* str, bool staticMem )

 {

     if ( staticMem ) {

-        value.SetInternedStr( str );

+        _value.SetInternedStr( str );

     }

     else {

-        value.SetStr( str );

+        _value.SetStr( str );

     }

 }

 

 

 void XMLNode::DeleteChildren()

 {

-    while( firstChild ) {

-        XMLNode* node = firstChild;

+    while( _firstChild ) {

+        XMLNode* node = _firstChild;

         Unlink( node );

 

         DELETE_NODE( node );

     }

-    firstChild = lastChild = 0;

+    _firstChild = _lastChild = 0;

 }

 

 

 void XMLNode::Unlink( XMLNode* child )

 {

-    TIXMLASSERT( child->parent == this );

-    if ( child == firstChild ) {

-        firstChild = firstChild->next;

+    TIXMLASSERT( child->_parent == this );

+    if ( child == _firstChild ) {

+        _firstChild = _firstChild->_next;

     }

-    if ( child == lastChild ) {

-        lastChild = lastChild->prev;

+    if ( child == _lastChild ) {

+        _lastChild = _lastChild->_prev;

     }

 

-    if ( child->prev ) {

-        child->prev->next = child->next;

+    if ( child->_prev ) {

+        child->_prev->_next = child->_next;

     }

-    if ( child->next ) {

-        child->next->prev = child->prev;

+    if ( child->_next ) {

+        child->_next->_prev = child->_prev;

     }

-    child->parent = 0;

+    child->_parent = 0;

 }

 

 

 void XMLNode::DeleteChild( XMLNode* node )

 {

-    TIXMLASSERT( node->parent == this );

+    TIXMLASSERT( node->_parent == this );

     DELETE_NODE( node );

 }

 

 

 XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )

 {

-    if ( lastChild ) {

-        TIXMLASSERT( firstChild );

-        TIXMLASSERT( lastChild->next == 0 );

-        lastChild->next = addThis;

-        addThis->prev = lastChild;

-        lastChild = addThis;

+    if ( _lastChild ) {

+        TIXMLASSERT( _firstChild );

+        TIXMLASSERT( _lastChild->_next == 0 );

+        _lastChild->_next = addThis;

+        addThis->_prev = _lastChild;

+        _lastChild = addThis;

 

-        addThis->next = 0;

+        addThis->_next = 0;

     }

     else {

-        TIXMLASSERT( firstChild == 0 );

-        firstChild = lastChild = addThis;

+        TIXMLASSERT( _firstChild == 0 );

+        _firstChild = _lastChild = addThis;

 

-        addThis->prev = 0;

-        addThis->next = 0;

+        addThis->_prev = 0;

+        addThis->_next = 0;

     }

-    addThis->parent = this;

+    addThis->_parent = this;

     return addThis;

 }

 

 

 XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )

 {

-    if ( firstChild ) {

-        TIXMLASSERT( lastChild );

-        TIXMLASSERT( firstChild->prev == 0 );

+    if ( _firstChild ) {

+        TIXMLASSERT( _lastChild );

+        TIXMLASSERT( _firstChild->_prev == 0 );

 

-        firstChild->prev = addThis;

-        addThis->next = firstChild;

-        firstChild = addThis;

+        _firstChild->_prev = addThis;

+        addThis->_next = _firstChild;

+        _firstChild = addThis;

 

-        addThis->prev = 0;

+        addThis->_prev = 0;

     }

     else {

-        TIXMLASSERT( lastChild == 0 );

-        firstChild = lastChild = addThis;

+        TIXMLASSERT( _lastChild == 0 );

+        _firstChild = _lastChild = addThis;

 

-        addThis->prev = 0;

-        addThis->next = 0;

+        addThis->_prev = 0;

+        addThis->_next = 0;

     }

-    addThis->parent = this;

+    addThis->_parent = this;

     return addThis;

 }

 

 

 XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )

 {

-    TIXMLASSERT( afterThis->parent == this );

-    if ( afterThis->parent != this ) {

+    TIXMLASSERT( afterThis->_parent == this );

+    if ( afterThis->_parent != this ) {

         return 0;

     }

 

-    if ( afterThis->next == 0 ) {

+    if ( afterThis->_next == 0 ) {

         // The last node or the only node.

         return InsertEndChild( addThis );

     }

-    addThis->prev = afterThis;

-    addThis->next = afterThis->next;

-    afterThis->next->prev = addThis;

-    afterThis->next = addThis;

-    addThis->parent = this;

+    addThis->_prev = afterThis;

+    addThis->_next = afterThis->_next;

+    afterThis->_next->_prev = addThis;

+    afterThis->_next = addThis;

+    addThis->_parent = this;

     return addThis;

 }

 

@@ -718,7 +718,7 @@
 

 const XMLElement* XMLNode::FirstChildElement( const char* value ) const

 {

-    for( XMLNode* node=firstChild; node; node=node->next ) {

+    for( XMLNode* node=_firstChild; node; node=node->_next ) {

         XMLElement* element = node->ToElement();

         if ( element ) {

             if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) {

@@ -732,7 +732,7 @@
 

 const XMLElement* XMLNode::LastChildElement( const char* value ) const

 {

-    for( XMLNode* node=lastChild; node; node=node->prev ) {

+    for( XMLNode* node=_lastChild; node; node=node->_prev ) {

         XMLElement* element = node->ToElement();

         if ( element ) {

             if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) {

@@ -746,7 +746,7 @@
 

 const XMLElement* XMLNode::NextSiblingElement( const char* value ) const

 {

-    for( XMLNode* element=this->next; element; element = element->next ) {

+    for( XMLNode* element=this->_next; element; element = element->_next ) {

         if (    element->ToElement()

                 && (!value || XMLUtil::StringEqual( value, element->Value() ))) {

             return element->ToElement();

@@ -758,7 +758,7 @@
 

 const XMLElement* XMLNode::PreviousSiblingElement( const char* value ) const

 {

-    for( XMLNode* element=this->prev; element; element = element->prev ) {

+    for( XMLNode* element=_prev; element; element = element->_prev ) {

         if (    element->ToElement()

                 && (!value || XMLUtil::StringEqual( value, element->Value() ))) {

             return element->ToElement();

@@ -790,7 +790,7 @@
     while( p && *p ) {

         XMLNode* node = 0;

 

-        p = document->Identify( p, &node );

+        p = _document->Identify( p, &node );

         if ( p == 0 || node == 0 ) {

             break;

         }

@@ -800,8 +800,8 @@
         if ( !p ) {

             DELETE_NODE( node );

             node = 0;

-            if ( !document->Error() ) {

-                document->SetError( XML_ERROR_PARSING, 0, 0 );

+            if ( !_document->Error() ) {

+                _document->SetError( XML_ERROR_PARSING, 0, 0 );

             }

             break;

         }

@@ -809,7 +809,7 @@
         // We read the end tag. Return it to the parent.

         if ( node->ToElement() && node->ToElement()->ClosingType() == XMLElement::CLOSING ) {

             if ( parentEnd ) {

-                *parentEnd = static_cast<XMLElement*>(node)->value;

+                *parentEnd = static_cast<XMLElement*>(node)->_value;

             }

             DELETE_NODE( node );

             return p;

@@ -820,16 +820,16 @@
         XMLElement* ele = node->ToElement();

         if ( ele ) {

             if ( endTag.Empty() && ele->ClosingType() == XMLElement::OPEN ) {

-                document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );

+                _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );

                 p = 0;

             }

             else if ( !endTag.Empty() && ele->ClosingType() != XMLElement::OPEN ) {

-                document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );

+                _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );

                 p = 0;

             }

             else if ( !endTag.Empty() ) {

                 if ( !XMLUtil::StringEqual( endTag.GetStr(), node->Value() )) {

-                    document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );

+                    _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );

                     p = 0;

                 }

             }

@@ -850,21 +850,21 @@
 {

     const char* start = p;

     if ( this->CData() ) {

-        p = value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION );

+        p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION );

         if ( !p ) {

-            document->SetError( XML_ERROR_PARSING_CDATA, start, 0 );

+            _document->SetError( XML_ERROR_PARSING_CDATA, start, 0 );

         }

         return p;

     }

     else {

-        int flags = document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;

-        if ( document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {

+        int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;

+        if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {

             flags |= StrPair::COLLAPSE_WHITESPACE;

         }

 

-        p = value.ParseText( p, "<", flags );

+        p = _value.ParseText( p, "<", flags );

         if ( !p ) {

-            document->SetError( XML_ERROR_PARSING_TEXT, start, 0 );

+            _document->SetError( XML_ERROR_PARSING_TEXT, start, 0 );

         }

         if ( p && *p ) {

             return p-1;

@@ -877,7 +877,7 @@
 XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const

 {

     if ( !doc ) {

-        doc = document;

+        doc = _document;

     }

     XMLText* text = doc->NewText( Value() );	// fixme: this will always allocate memory. Intern?

     text->SetCData( this->CData() );

@@ -906,7 +906,6 @@
 

 XMLComment::~XMLComment()

 {

-    //printf( "~XMLComment\n" );

 }

 

 

@@ -914,9 +913,9 @@
 {

     // Comment parses as text.

     const char* start = p;

-    p = value.ParseText( p, "-->", StrPair::COMMENT );

+    p = _value.ParseText( p, "-->", StrPair::COMMENT );

     if ( p == 0 ) {

-        document->SetError( XML_ERROR_PARSING_COMMENT, start, 0 );

+        _document->SetError( XML_ERROR_PARSING_COMMENT, start, 0 );

     }

     return p;

 }

@@ -925,7 +924,7 @@
 XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const

 {

     if ( !doc ) {

-        doc = document;

+        doc = _document;

     }

     XMLComment* comment = doc->NewComment( Value() );	// fixme: this will always allocate memory. Intern?

     return comment;

@@ -961,9 +960,9 @@
 {

     // Declaration parses as text.

     const char* start = p;

-    p = value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION );

+    p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION );

     if ( p == 0 ) {

-        document->SetError( XML_ERROR_PARSING_DECLARATION, start, 0 );

+        _document->SetError( XML_ERROR_PARSING_DECLARATION, start, 0 );

     }

     return p;

 }

@@ -972,7 +971,7 @@
 XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const

 {

     if ( !doc ) {

-        doc = document;

+        doc = _document;

     }

     XMLDeclaration* dec = doc->NewDeclaration( Value() );	// fixme: this will always allocate memory. Intern?

     return dec;

@@ -1008,9 +1007,9 @@
     // Unknown parses as text.

     const char* start = p;

 

-    p = value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION );

+    p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION );

     if ( !p ) {

-        document->SetError( XML_ERROR_PARSING_UNKNOWN, start, 0 );

+        _document->SetError( XML_ERROR_PARSING_UNKNOWN, start, 0 );

     }

     return p;

 }

@@ -1019,7 +1018,7 @@
 XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const

 {

     if ( !doc ) {

-        doc = document;

+        doc = _document;

     }

     XMLUnknown* text = doc->NewUnknown( Value() );	// fixme: this will always allocate memory. Intern?

     return text;

@@ -1041,7 +1040,7 @@
 char* XMLAttribute::ParseDeep( char* p, bool processEntities )

 {

     // Parse using the name rules: bug fix, was using ParseText before

-    p = name.ParseName( p );

+    p = _name.ParseName( p );

     if ( !p || !*p ) {

         return 0;

     }

@@ -1061,14 +1060,14 @@
     char endTag[2] = { *p, 0 };

     ++p;	// move past opening quote

 

-    p = value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES );

+    p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES );

     return p;

 }

 

 

 void XMLAttribute::SetName( const char* n )

 {

-    name.SetStr( n );

+    _name.SetStr( n );

 }

 

 

@@ -1119,7 +1118,7 @@
 

 void XMLAttribute::SetAttribute( const char* v )

 {

-    value.SetStr( v );

+    _value.SetStr( v );

 }

 

 

@@ -1127,7 +1126,7 @@
 {

     char buf[BUF_SIZE];

     XMLUtil::ToStr( v, buf, BUF_SIZE );

-    value.SetStr( buf );

+    _value.SetStr( buf );

 }

 

 

@@ -1135,7 +1134,7 @@
 {

     char buf[BUF_SIZE];

     XMLUtil::ToStr( v, buf, BUF_SIZE );

-    value.SetStr( buf );

+    _value.SetStr( buf );

 }

 

 

@@ -1143,38 +1142,38 @@
 {

     char buf[BUF_SIZE];

     XMLUtil::ToStr( v, buf, BUF_SIZE );

-    value.SetStr( buf );

+    _value.SetStr( buf );

 }

 

 void XMLAttribute::SetAttribute( double v )

 {

     char buf[BUF_SIZE];

     XMLUtil::ToStr( v, buf, BUF_SIZE );

-    value.SetStr( buf );

+    _value.SetStr( buf );

 }

 

 void XMLAttribute::SetAttribute( float v )

 {

     char buf[BUF_SIZE];

     XMLUtil::ToStr( v, buf, BUF_SIZE );

-    value.SetStr( buf );

+    _value.SetStr( buf );

 }

 

 

 // --------- XMLElement ---------- //

 XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),

-    closingType( 0 ),

-    rootAttribute( 0 )

+    _closingType( 0 ),

+    _rootAttribute( 0 )

 {

 }

 

 

 XMLElement::~XMLElement()

 {

-    while( rootAttribute ) {

-        XMLAttribute* next = rootAttribute->next;

-        DELETE_ATTRIBUTE( rootAttribute );

-        rootAttribute = next;

+    while( _rootAttribute ) {

+        XMLAttribute* next = _rootAttribute->_next;

+        DELETE_ATTRIBUTE( _rootAttribute );

+        _rootAttribute = next;

     }

 }

 

@@ -1182,7 +1181,7 @@
 XMLAttribute* XMLElement::FindAttribute( const char* name )

 {

     XMLAttribute* a = 0;

-    for( a=rootAttribute; a; a = a->next ) {

+    for( a=_rootAttribute; a; a = a->_next ) {

         if ( XMLUtil::StringEqual( a->Name(), name ) ) {

             return a;

         }

@@ -1194,7 +1193,7 @@
 const XMLAttribute* XMLElement::FindAttribute( const char* name ) const

 {

     XMLAttribute* a = 0;

-    for( a=rootAttribute; a; a = a->next ) {

+    for( a=_rootAttribute; a; a = a->_next ) {

         if ( XMLUtil::StringEqual( a->Name(), name ) ) {

             return a;

         }

@@ -1295,21 +1294,21 @@
 {

     XMLAttribute* last = 0;

     XMLAttribute* attrib = 0;

-    for( attrib = rootAttribute;

+    for( attrib = _rootAttribute;

             attrib;

-            last = attrib, attrib = attrib->next ) {

+            last = attrib, attrib = attrib->_next ) {

         if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {

             break;

         }

     }

     if ( !attrib ) {

-        attrib = new (document->attributePool.Alloc() ) XMLAttribute();

-        attrib->memPool = &document->attributePool;

+        attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();

+        attrib->_memPool = &_document->_attributePool;

         if ( last ) {

-            last->next = attrib;

+            last->_next = attrib;

         }

         else {

-            rootAttribute = attrib;

+            _rootAttribute = attrib;

         }

         attrib->SetName( name );

     }

@@ -1320,13 +1319,13 @@
 void XMLElement::DeleteAttribute( const char* name )

 {

     XMLAttribute* prev = 0;

-    for( XMLAttribute* a=rootAttribute; a; a=a->next ) {

+    for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {

         if ( XMLUtil::StringEqual( name, a->Name() ) ) {

             if ( prev ) {

-                prev->next = a->next;

+                prev->_next = a->_next;

             }

             else {

-                rootAttribute = a->next;

+                _rootAttribute = a->_next;

             }

             DELETE_ATTRIBUTE( a );

             break;

@@ -1345,19 +1344,19 @@
     while( p ) {

         p = XMLUtil::SkipWhiteSpace( p );

         if ( !p || !(*p) ) {

-            document->SetError( XML_ERROR_PARSING_ELEMENT, start, Name() );

+            _document->SetError( XML_ERROR_PARSING_ELEMENT, start, Name() );

             return 0;

         }

 

         // attribute.

         if ( XMLUtil::IsAlpha( *p ) ) {

-            XMLAttribute* attrib = new (document->attributePool.Alloc() ) XMLAttribute();

-            attrib->memPool = &document->attributePool;

+            XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();

+            attrib->_memPool = &_document->_attributePool;

 

-            p = attrib->ParseDeep( p, document->ProcessEntities() );

+            p = attrib->ParseDeep( p, _document->ProcessEntities() );

             if ( !p || Attribute( attrib->Name() ) ) {

                 DELETE_ATTRIBUTE( attrib );

-                document->SetError( XML_ERROR_PARSING_ATTRIBUTE, start, p );

+                _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, start, p );

                 return 0;

             }

             // There is a minor bug here: if the attribute in the source xml

@@ -1366,16 +1365,16 @@
             // avoids re-scanning the attribute list. Preferring performance for

             // now, may reconsider in the future.

             if ( prevAttribute ) {

-                prevAttribute->next = attrib;

+                prevAttribute->_next = attrib;

             }

             else {

-                rootAttribute = attrib;

+                _rootAttribute = attrib;

             }

             prevAttribute = attrib;

         }

         // end of the tag

         else if ( *p == '/' && *(p+1) == '>' ) {

-            closingType = CLOSED;

+            _closingType = CLOSED;

             return p+2;	// done; sealed element.

         }

         // end of the tag

@@ -1384,7 +1383,7 @@
             break;

         }

         else {

-            document->SetError( XML_ERROR_PARSING_ELEMENT, start, p );

+            _document->SetError( XML_ERROR_PARSING_ELEMENT, start, p );

             return 0;

         }

     }

@@ -1408,17 +1407,17 @@
     // parsed just like a regular element then deleted from

     // the DOM.

     if ( *p == '/' ) {

-        closingType = CLOSING;

+        _closingType = CLOSING;

         ++p;

     }

 

-    p = value.ParseName( p );

-    if ( value.Empty() ) {

+    p = _value.ParseName( p );

+    if ( _value.Empty() ) {

         return 0;

     }

 

     p = ParseAttributes( p );

-    if ( !p || !*p || closingType ) {

+    if ( !p || !*p || _closingType ) {

         return p;

     }

 

@@ -1431,7 +1430,7 @@
 XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const

 {

     if ( !doc ) {

-        doc = document;

+        doc = _document;

     }

     XMLElement* element = doc->NewElement( Value() );					// fixme: this will always allocate memory. Intern?

     for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) {

@@ -1468,7 +1467,7 @@
 

 bool XMLElement::Accept( XMLVisitor* visitor ) const

 {

-    if ( visitor->VisitEnter( *this, rootAttribute ) ) {

+    if ( visitor->VisitEnter( *this, _rootAttribute ) ) {

         for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {

             if ( !node->Accept( visitor ) ) {

                 break;

@@ -1480,24 +1479,24 @@
 

 

 // --------- XMLDocument ----------- //

-XMLDocument::XMLDocument( bool _processEntities, Whitespace _whitespace ) :

+XMLDocument::XMLDocument( bool processEntities, Whitespace whitespace ) :

     XMLNode( 0 ),

-    writeBOM( false ),

-    processEntities( _processEntities ),

-    errorID( 0 ),

-    whitespace( _whitespace ),

-    errorStr1( 0 ),

-    errorStr2( 0 ),

-    charBuffer( 0 )

+    _writeBOM( false ),

+    _processEntities( processEntities ),

+    _errorID( 0 ),

+    _whitespace( whitespace ),

+    _errorStr1( 0 ),

+    _errorStr2( 0 ),

+    _charBuffer( 0 )

 {

-    document = this;	// avoid warning about 'this' in initializer list

+    _document = this;	// avoid warning about 'this' in initializer list

 }

 

 

 XMLDocument::~XMLDocument()

 {

     DeleteChildren();

-    delete [] charBuffer;

+    delete [] _charBuffer;

 

 #if 0

     textPool.Trace( "text" );

@@ -1506,29 +1505,28 @@
     attributePool.Trace( "attribute" );

 #endif

 

-    TIXMLASSERT( textPool.CurrentAllocs() == 0 );

-    TIXMLASSERT( elementPool.CurrentAllocs() == 0 );

-    TIXMLASSERT( commentPool.CurrentAllocs() == 0 );

-    TIXMLASSERT( attributePool.CurrentAllocs() == 0 );

+    TIXMLASSERT( _textPool.CurrentAllocs() == 0 );

+    TIXMLASSERT( _elementPool.CurrentAllocs() == 0 );

+    TIXMLASSERT( _commentPool.CurrentAllocs() == 0 );

+    TIXMLASSERT( _attributePool.CurrentAllocs() == 0 );

 }

 

 

 void XMLDocument::InitDocument()

 {

-    errorID = XML_NO_ERROR;

-    errorStr1 = 0;

-    errorStr2 = 0;

+    _errorID = XML_NO_ERROR;

+    _errorStr1 = 0;

+    _errorStr2 = 0;

 

-    delete [] charBuffer;

-    charBuffer = 0;

-

+    delete [] _charBuffer;

+    _charBuffer = 0;

 }

 

 

 XMLElement* XMLDocument::NewElement( const char* name )

 {

-    XMLElement* ele = new (elementPool.Alloc()) XMLElement( this );

-    ele->memPool = &elementPool;

+    XMLElement* ele = new (_elementPool.Alloc()) XMLElement( this );

+    ele->_memPool = &_elementPool;

     ele->SetName( name );

     return ele;

 }

@@ -1536,8 +1534,8 @@
 

 XMLComment* XMLDocument::NewComment( const char* str )

 {

-    XMLComment* comment = new (commentPool.Alloc()) XMLComment( this );

-    comment->memPool = &commentPool;

+    XMLComment* comment = new (_commentPool.Alloc()) XMLComment( this );

+    comment->_memPool = &_commentPool;

     comment->SetValue( str );

     return comment;

 }

@@ -1545,8 +1543,8 @@
 

 XMLText* XMLDocument::NewText( const char* str )

 {

-    XMLText* text = new (textPool.Alloc()) XMLText( this );

-    text->memPool = &textPool;

+    XMLText* text = new (_textPool.Alloc()) XMLText( this );

+    text->_memPool = &_textPool;

     text->SetValue( str );

     return text;

 }

@@ -1554,8 +1552,8 @@
 

 XMLDeclaration* XMLDocument::NewDeclaration( const char* str )

 {

-    XMLDeclaration* dec = new (commentPool.Alloc()) XMLDeclaration( this );

-    dec->memPool = &commentPool;

+    XMLDeclaration* dec = new (_commentPool.Alloc()) XMLDeclaration( this );

+    dec->_memPool = &_commentPool;

     dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );

     return dec;

 }

@@ -1563,8 +1561,8 @@
 

 XMLUnknown* XMLDocument::NewUnknown( const char* str )

 {

-    XMLUnknown* unk = new (commentPool.Alloc()) XMLUnknown( this );

-    unk->memPool = &commentPool;

+    XMLUnknown* unk = new (_commentPool.Alloc()) XMLUnknown( this );

+    unk->_memPool = &_commentPool;

     unk->SetValue( str );

     return unk;

 }

@@ -1584,11 +1582,11 @@
     if ( !fp) {

 #endif

         SetError( XML_ERROR_FILE_NOT_FOUND, filename, 0 );

-        return errorID;

+        return _errorID;

     }

     LoadFile( fp );

     fclose( fp );

-    return errorID;

+    return _errorID;

 }

 

 

@@ -1602,28 +1600,28 @@
     fseek( fp, 0, SEEK_SET );

 

     if ( size == 0 ) {

-        return errorID;

+        return _errorID;

     }

 

-    charBuffer = new char[size+1];

-    size_t read = fread( charBuffer, 1, size, fp );

+    _charBuffer = new char[size+1];

+    size_t read = fread( _charBuffer, 1, size, fp );

     if ( read != size ) {

         SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );

-        return errorID;

+        return _errorID;

     }

 

-    charBuffer[size] = 0;

+    _charBuffer[size] = 0;

 

-    const char* p = charBuffer;

+    const char* p = _charBuffer;

     p = XMLUtil::SkipWhiteSpace( p );

-    p = XMLUtil::ReadBOM( p, &writeBOM );

+    p = XMLUtil::ReadBOM( p, &_writeBOM );

     if ( !p || !*p ) {

         SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );

-        return errorID;

+        return _errorID;

     }

 

-    ParseDeep( charBuffer + (p-charBuffer), 0 );

-    return errorID;

+    ParseDeep( _charBuffer + (p-_charBuffer), 0 );

+    return _errorID;

 }

 

 

@@ -1638,11 +1636,11 @@
     if ( !fp) {

 #endif

         SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, filename, 0 );

-        return errorID;

+        return _errorID;

     }

     SaveFile(fp, compact);

     fclose( fp );

-    return errorID;

+    return _errorID;

 }

 

 

@@ -1650,7 +1648,7 @@
 {

     XMLPrinter stream( fp, compact );

     Print( &stream );

-    return errorID;

+    return _errorID;

 }

 

 

@@ -1661,24 +1659,24 @@
 

     if ( !p || !*p ) {

         SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );

-        return errorID;

+        return _errorID;

     }

     if ( len == (size_t)(-1) ) {

         len = strlen( p );

     }

-    charBuffer = new char[ len+1 ];

-    memcpy( charBuffer, p, len );

-    charBuffer[len] = 0;

+    _charBuffer = new char[ len+1 ];

+    memcpy( _charBuffer, p, len );

+    _charBuffer[len] = 0;

 

     p = XMLUtil::SkipWhiteSpace( p );

-    p = XMLUtil::ReadBOM( p, &writeBOM );

+    p = XMLUtil::ReadBOM( p, &_writeBOM );

     if ( !p || !*p ) {

         SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );

-        return errorID;

+        return _errorID;

     }

 

-    ParseDeep( charBuffer, 0 );

-    return errorID;

+    ParseDeep( _charBuffer, 0 );

+    return _errorID;

 }

 

 

@@ -1694,55 +1692,55 @@
 

 void XMLDocument::SetError( int error, const char* str1, const char* str2 )

 {

-    errorID = error;

-    errorStr1 = str1;

-    errorStr2 = str2;

+    _errorID = error;

+    _errorStr1 = str1;

+    _errorStr2 = str2;

 }

 

 

 void XMLDocument::PrintError() const

 {

-    if ( errorID ) {

+    if ( _errorID ) {

         static const int LEN = 20;

         char buf1[LEN] = { 0 };

         char buf2[LEN] = { 0 };

 

-        if ( errorStr1 ) {

-            TIXML_SNPRINTF( buf1, LEN, "%s", errorStr1 );

+        if ( _errorStr1 ) {

+            TIXML_SNPRINTF( buf1, LEN, "%s", _errorStr1 );

         }

-        if ( errorStr2 ) {

-            TIXML_SNPRINTF( buf2, LEN, "%s", errorStr2 );

+        if ( _errorStr2 ) {

+            TIXML_SNPRINTF( buf2, LEN, "%s", _errorStr2 );

         }

 

         printf( "XMLDocument error id=%d str1=%s str2=%s\n",

-                errorID, buf1, buf2 );

+                _errorID, buf1, buf2 );

     }

 }

 

 

 XMLPrinter::XMLPrinter( FILE* file, bool compact ) :

-    elementJustOpened( false ),

-    firstElement( true ),

-    fp( file ),

-    depth( 0 ),

-    textDepth( -1 ),

-    processEntities( true ),

-    compactMode( compact )

+    _elementJustOpened( false ),

+    _firstElement( true ),

+    _fp( file ),

+    _depth( 0 ),

+    _textDepth( -1 ),

+    _processEntities( true ),

+    _compactMode( compact )

 {

     for( int i=0; i<ENTITY_RANGE; ++i ) {

-        entityFlag[i] = false;

-        restrictedEntityFlag[i] = false;

+        _entityFlag[i] = false;

+        _restrictedEntityFlag[i] = false;

     }

     for( int i=0; i<NUM_ENTITIES; ++i ) {

         TIXMLASSERT( entities[i].value < ENTITY_RANGE );

         if ( entities[i].value < ENTITY_RANGE ) {

-            entityFlag[ (int)entities[i].value ] = true;

+            _entityFlag[ (int)entities[i].value ] = true;

         }

     }

-    restrictedEntityFlag[(int)'&'] = true;

-    restrictedEntityFlag[(int)'<'] = true;

-    restrictedEntityFlag[(int)'>'] = true;	// not required, but consistency is nice

-    buffer.Push( 0 );

+    _restrictedEntityFlag[(int)'&'] = true;

+    _restrictedEntityFlag[(int)'<'] = true;

+    _restrictedEntityFlag[(int)'>'] = true;	// not required, but consistency is nice

+    _buffer.Push( 0 );

 }

 

 

@@ -1751,8 +1749,8 @@
     va_list     va;

     va_start( va, format );

 

-    if ( fp ) {

-        vfprintf( fp, format, va );

+    if ( _fp ) {

+        vfprintf( _fp, format, va );

     }

     else {

         // This seems brutally complex. Haven't figured out a better

@@ -1761,20 +1759,20 @@
         int len = -1;

         int expand = 1000;

         while ( len < 0 ) {

-            len = vsnprintf_s( accumulator.Mem(), accumulator.Capacity(), _TRUNCATE, format, va );

+            len = vsnprintf_s( _accumulator.Mem(), _accumulator.Capacity(), _TRUNCATE, format, va );

             if ( len < 0 ) {

                 expand *= 3/2;

                 accumulator.PushArr( expand );

             }

         }

-        char* p = buffer.PushArr( len ) - 1;

-        memcpy( p, accumulator.Mem(), len+1 );

+        char* p = _buffer.PushArr( len ) - 1;

+        memcpy( p, _accumulator.Mem(), len+1 );

 #else

         int len = vsnprintf( 0, 0, format, va );

         // Close out and re-start the va-args

         va_end( va );

         va_start( va, format );

-        char* p = buffer.PushArr( len ) - 1;

+        char* p = _buffer.PushArr( len ) - 1;

         vsnprintf( p, len+1, format, va );

 #endif

     }

@@ -1794,9 +1792,9 @@
 {

     // Look for runs of bytes between entities to print.

     const char* q = p;

-    const bool* flag = restricted ? restrictedEntityFlag : entityFlag;

+    const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;

 

-    if ( processEntities ) {

+    if ( _processEntities ) {

         while ( *q ) {

             // Remember, char is sometimes signed. (How many times has that bitten me?)

             if ( *q > 0 && *q < ENTITY_RANGE ) {

@@ -1822,7 +1820,7 @@
     }

     // Flush the remaining string. This will be the entire

     // string if an entity wasn't found.

-    if ( !processEntities || (q-p > 0) ) {

+    if ( !_processEntities || (q-p > 0) ) {

         Print( "%s", p );

     }

 }

@@ -1842,26 +1840,26 @@
 

 void XMLPrinter::OpenElement( const char* name )

 {

-    if ( elementJustOpened ) {

+    if ( _elementJustOpened ) {

         SealElement();

     }

-    stack.Push( name );

+    _stack.Push( name );

 

-    if ( textDepth < 0 && !firstElement && !compactMode ) {

+    if ( _textDepth < 0 && !_firstElement && !_compactMode ) {

         Print( "\n" );

-        PrintSpace( depth );

+        PrintSpace( _depth );

     }

 

     Print( "<%s", name );

-    elementJustOpened = true;

-    firstElement = false;

-    ++depth;

+    _elementJustOpened = true;

+    _firstElement = false;

+    ++_depth;

 }

 

 

 void XMLPrinter::PushAttribute( const char* name, const char* value )

 {

-    TIXMLASSERT( elementJustOpened );

+    TIXMLASSERT( _elementJustOpened );

     Print( " %s=\"", name );

     PrintString( value, false );

     Print( "\"" );

@@ -1902,42 +1900,42 @@
 

 void XMLPrinter::CloseElement()

 {

-    --depth;

-    const char* name = stack.Pop();

+    --_depth;

+    const char* name = _stack.Pop();

 

-    if ( elementJustOpened ) {

+    if ( _elementJustOpened ) {

         Print( "/>" );

     }

     else {

-        if ( textDepth < 0 && !compactMode) {

+        if ( _textDepth < 0 && !_compactMode) {

             Print( "\n" );

-            PrintSpace( depth );

+            PrintSpace( _depth );

         }

         Print( "</%s>", name );

     }

 

-    if ( textDepth == depth ) {

-        textDepth = -1;

+    if ( _textDepth == _depth ) {

+        _textDepth = -1;

     }

-    if ( depth == 0 && !compactMode) {

+    if ( _depth == 0 && !_compactMode) {

         Print( "\n" );

     }

-    elementJustOpened = false;

+    _elementJustOpened = false;

 }

 

 

 void XMLPrinter::SealElement()

 {

-    elementJustOpened = false;

+    _elementJustOpened = false;

     Print( ">" );

 }

 

 

 void XMLPrinter::PushText( const char* text, bool cdata )

 {

-    textDepth = depth-1;

+    _textDepth = _depth-1;

 

-    if ( elementJustOpened ) {

+    if ( _elementJustOpened ) {

         SealElement();

     }

     if ( cdata ) {

@@ -1992,49 +1990,49 @@
 

 void XMLPrinter::PushComment( const char* comment )

 {

-    if ( elementJustOpened ) {

+    if ( _elementJustOpened ) {

         SealElement();

     }

-    if ( textDepth < 0 && !firstElement && !compactMode) {

+    if ( _textDepth < 0 && !_firstElement && !_compactMode) {

         Print( "\n" );

-        PrintSpace( depth );

+        PrintSpace( _depth );

     }

-    firstElement = false;

+    _firstElement = false;

     Print( "<!--%s-->", comment );

 }

 

 

 void XMLPrinter::PushDeclaration( const char* value )

 {

-    if ( elementJustOpened ) {

+    if ( _elementJustOpened ) {

         SealElement();

     }

-    if ( textDepth < 0 && !firstElement && !compactMode) {

+    if ( _textDepth < 0 && !_firstElement && !_compactMode) {

         Print( "\n" );

-        PrintSpace( depth );

+        PrintSpace( _depth );

     }

-    firstElement = false;

+    _firstElement = false;

     Print( "<?%s?>", value );

 }

 

 

 void XMLPrinter::PushUnknown( const char* value )

 {

-    if ( elementJustOpened ) {

+    if ( _elementJustOpened ) {

         SealElement();

     }

-    if ( textDepth < 0 && !firstElement && !compactMode) {

+    if ( _textDepth < 0 && !_firstElement && !_compactMode) {

         Print( "\n" );

-        PrintSpace( depth );

+        PrintSpace( _depth );

     }

-    firstElement = false;

+    _firstElement = false;

     Print( "<!%s>", value );

 }

 

 

 bool XMLPrinter::VisitEnter( const XMLDocument& doc )

 {

-    processEntities = doc.ProcessEntities();

+    _processEntities = doc.ProcessEntities();

     if ( doc.HasBOM() ) {

         PushHeader( true, false );

     }