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 );
}
diff --git a/tinyxml2.h b/tinyxml2.h
index ca80039..f6b3ba6 100755
--- a/tinyxml2.h
+++ b/tinyxml2.h
@@ -129,12 +129,12 @@
NEEDS_NEWLINE_NORMALIZATION = 0x02,
COLLAPSE_WHITESPACE = 0x04,
- TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+ TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
- ATTRIBUTE_NAME = 0,
- ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
- ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
- COMMENT = NEEDS_NEWLINE_NORMALIZATION
+ ATTRIBUTE_NAME = 0,
+ ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+ ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
+ COMMENT = NEEDS_NEWLINE_NORMALIZATION
};
StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
@@ -189,58 +189,58 @@
{
public:
DynArray< T, INIT >() {
- _mem = pool;
- allocated = INIT;
- size = 0;
+ _mem = _pool;
+ _allocated = INIT;
+ _size = 0;
}
~DynArray() {
- if ( _mem != pool ) {
+ if ( _mem != _pool ) {
delete [] _mem;
}
}
void Push( T t ) {
- EnsureCapacity( size+1 );
- _mem[size++] = t;
+ EnsureCapacity( _size+1 );
+ _mem[_size++] = t;
}
T* PushArr( int count ) {
- EnsureCapacity( size+count );
- T* ret = &_mem[size];
- size += count;
+ EnsureCapacity( _size+count );
+ T* ret = &_mem[_size];
+ _size += count;
return ret;
}
T Pop() {
- return _mem[--size];
+ return _mem[--_size];
}
void PopArr( int count ) {
- TIXMLASSERT( size >= count );
- size -= count;
+ TIXMLASSERT( _size >= count );
+ _size -= count;
}
bool Empty() const {
- return size == 0;
+ return _size == 0;
}
T& operator[](int i) {
- TIXMLASSERT( i>= 0 && i < size );
+ TIXMLASSERT( i>= 0 && i < _size );
return _mem[i];
}
const T& operator[](int i) const {
- TIXMLASSERT( i>= 0 && i < size );
+ TIXMLASSERT( i>= 0 && i < _size );
return _mem[i];
}
int Size() const {
- return size;
+ return _size;
}
int Capacity() const {
- return allocated;
+ return _allocated;
}
const T* Mem() const {
@@ -253,22 +253,22 @@
private:
void EnsureCapacity( int cap ) {
- if ( cap > allocated ) {
+ if ( cap > _allocated ) {
int newAllocated = cap * 2;
T* newMem = new T[newAllocated];
- memcpy( newMem, _mem, sizeof(T)*size ); // warning: not using constructors, only works for PODs
- if ( _mem != pool ) {
+ memcpy( newMem, _mem, sizeof(T)*_size ); // warning: not using constructors, only works for PODs
+ if ( _mem != _pool ) {
delete [] _mem;
}
_mem = newMem;
- allocated = newAllocated;
+ _allocated = newAllocated;
}
}
- T* _mem;
- T pool[INIT];
- int allocated; // objects allocated
- int size; // number objects in use
+ T* _mem;
+ T _pool[INIT];
+ int _allocated; // objects allocated
+ int _size; // number objects in use
};
@@ -295,11 +295,11 @@
class MemPoolT : public MemPool
{
public:
- MemPoolT() : root(0), currentAllocs(0), nAllocs(0), maxAllocs(0) {}
+ MemPoolT() : _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0) {}
~MemPoolT() {
// Delete the blocks.
- for( int i=0; i<blockPtrs.Size(); ++i ) {
- delete blockPtrs[i];
+ for( int i=0; i<_blockPtrs.Size(); ++i ) {
+ delete _blockPtrs[i];
}
}
@@ -307,63 +307,63 @@
return SIZE;
}
int CurrentAllocs() const {
- return currentAllocs;
+ return _currentAllocs;
}
virtual void* Alloc() {
- if ( !root ) {
+ if ( !_root ) {
// Need a new block.
Block* block = new Block();
- blockPtrs.Push( block );
+ _blockPtrs.Push( block );
for( int i=0; i<COUNT-1; ++i ) {
block->chunk[i].next = &block->chunk[i+1];
}
block->chunk[COUNT-1].next = 0;
- root = block->chunk;
+ _root = block->chunk;
}
- void* result = root;
- root = root->next;
+ void* result = _root;
+ _root = _root->next;
- ++currentAllocs;
- if ( currentAllocs > maxAllocs ) {
- maxAllocs = currentAllocs;
+ ++_currentAllocs;
+ if ( _currentAllocs > _maxAllocs ) {
+ _maxAllocs = _currentAllocs;
}
- nAllocs++;
+ _nAllocs++;
return result;
}
virtual void Free( void* mem ) {
if ( !mem ) {
return;
}
- --currentAllocs;
+ --_currentAllocs;
Chunk* chunk = (Chunk*)mem;
#ifdef DEBUG
memset( chunk, 0xfe, sizeof(Chunk) );
#endif
- chunk->next = root;
- root = chunk;
+ chunk->next = _root;
+ _root = chunk;
}
void Trace( const char* name ) {
printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
- name, maxAllocs, maxAllocs*SIZE/1024, currentAllocs, SIZE, nAllocs, blockPtrs.Size() );
+ name, _maxAllocs, _maxAllocs*SIZE/1024, _currentAllocs, SIZE, _nAllocs, _blockPtrs.Size() );
}
private:
enum { COUNT = 1024/SIZE };
union Chunk {
- Chunk* next;
- char mem[SIZE];
+ Chunk* next;
+ char mem[SIZE];
};
struct Block {
Chunk chunk[COUNT];
};
- DynArray< Block*, 10 > blockPtrs;
- Chunk* root;
+ DynArray< Block*, 10 > _blockPtrs;
+ Chunk* _root;
- int currentAllocs;
- int nAllocs;
- int maxAllocs;
+ int _currentAllocs;
+ int _nAllocs;
+ int _maxAllocs;
};
@@ -533,11 +533,11 @@
/// Get the XMLDocument that owns this XMLNode.
const XMLDocument* GetDocument() const {
- return document;
+ return _document;
}
/// Get the XMLDocument that owns this XMLNode.
XMLDocument* GetDocument() {
- return document;
+ return _document;
}
virtual XMLElement* ToElement() {
@@ -588,8 +588,9 @@
@endverbatim
*/
const char* Value() const {
- return value.GetStr();
+ return _value.GetStr();
}
+
/** Set the Value of an XML node.
@sa Value()
*/
@@ -597,36 +598,41 @@
/// Get the parent of this node on the DOM.
const XMLNode* Parent() const {
- return parent;
+ return _parent;
}
+
XMLNode* Parent() {
- return parent;
+ return _parent;
}
/// Returns true if this node has no children.
bool NoChildren() const {
- return !firstChild;
+ return !_firstChild;
}
/// Get the first child node, or null if none exists.
const XMLNode* FirstChild() const {
- return firstChild;
+ return _firstChild;
}
+
XMLNode* FirstChild() {
- return firstChild;
+ return _firstChild;
}
+
/** Get the first child element, or optionally the first child
element with the specified name.
*/
const XMLElement* FirstChildElement( const char* value=0 ) const;
- XMLElement* FirstChildElement( const char* _value=0 ) {
- return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( _value ));
+
+ XMLElement* FirstChildElement( const char* value=0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( value ));
}
/// Get the last child node, or null if none exists.
const XMLNode* LastChild() const {
- return lastChild;
+ return _lastChild;
}
+
XMLNode* LastChild() {
return const_cast<XMLNode*>(const_cast<const XMLNode*>(this)->LastChild() );
}
@@ -635,36 +641,41 @@
element with the specified name.
*/
const XMLElement* LastChildElement( const char* value=0 ) const;
- XMLElement* LastChildElement( const char* _value=0 ) {
- return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(_value) );
+
+ XMLElement* LastChildElement( const char* value=0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(value) );
}
/// Get the previous (left) sibling node of this node.
const XMLNode* PreviousSibling() const {
- return prev;
+ return _prev;
}
+
XMLNode* PreviousSibling() {
- return prev;
+ return _prev;
}
/// Get the previous (left) sibling element of this node, with an opitionally supplied name.
const XMLElement* PreviousSiblingElement( const char* value=0 ) const ;
- XMLElement* PreviousSiblingElement( const char* _value=0 ) {
- return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( _value ) );
+
+ XMLElement* PreviousSiblingElement( const char* value=0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( value ) );
}
/// Get the next (right) sibling node of this node.
const XMLNode* NextSibling() const {
- return next;
+ return _next;
}
+
XMLNode* NextSibling() {
- return next;
+ return _next;
}
/// Get the next (right) sibling element of this node, with an opitionally supplied name.
const XMLElement* NextSiblingElement( const char* value=0 ) const;
- XMLElement* NextSiblingElement( const char* _value=0 ) {
- return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( _value ) );
+
+ XMLElement* NextSiblingElement( const char* value=0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( value ) );
}
/**
@@ -746,18 +757,18 @@
XMLNode( const XMLNode& ); // not supported
XMLNode& operator=( const XMLNode& ); // not supported
- XMLDocument* document;
- XMLNode* parent;
- mutable StrPair value;
+ XMLDocument* _document;
+ XMLNode* _parent;
+ mutable StrPair _value;
- XMLNode* firstChild;
- XMLNode* lastChild;
+ XMLNode* _firstChild;
+ XMLNode* _lastChild;
- XMLNode* prev;
- XMLNode* next;
+ XMLNode* _prev;
+ XMLNode* _next;
private:
- MemPool* memPool;
+ MemPool* _memPool;
void Unlink( XMLNode* child );
};
@@ -781,35 +792,34 @@
public:
virtual bool Accept( XMLVisitor* visitor ) const;
- virtual XMLText* ToText() {
+ virtual XMLText* ToText() {
return this;
}
- virtual const XMLText* ToText() const {
+ virtual const XMLText* ToText() const {
return this;
}
/// Declare whether this should be CDATA or standard text.
- void SetCData( bool _isCData ) {
- this->isCData = _isCData;
+ void SetCData( bool isCData ) {
+ _isCData = isCData;
}
/// Returns true if this is a CDATA text element.
bool CData() const {
- return isCData;
+ return _isCData;
}
char* ParseDeep( char*, StrPair* endTag );
virtual XMLNode* ShallowClone( XMLDocument* document ) const;
virtual bool ShallowEqual( const XMLNode* compare ) const;
-
protected:
- XMLText( XMLDocument* doc ) : XMLNode( doc ), isCData( false ) {}
+ XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
virtual ~XMLText() {}
XMLText( const XMLText& ); // not supported
XMLText& operator=( const XMLText& ); // not supported
private:
- bool isCData;
+ bool _isCData;
};
@@ -948,13 +958,13 @@
friend class XMLElement;
public:
const char* Name() const {
- return name.GetStr(); ///< The name of the attribute.
+ return _name.GetStr(); ///< The name of the attribute.
}
const char* Value() const {
- return value.GetStr(); ///< The value of the attribute.
+ return _value.GetStr(); ///< The value of the attribute.
}
const XMLAttribute* Next() const {
- return next; ///< The next attribute in the list.
+ return _next; ///< The next attribute in the list.
}
/** IntAttribute interprets the attribute as an integer, and returns the value.
@@ -1021,18 +1031,19 @@
private:
enum { BUF_SIZE = 200 };
- XMLAttribute() : next( 0 ) {}
+ XMLAttribute() : _next( 0 ) {}
virtual ~XMLAttribute() {}
+
XMLAttribute( const XMLAttribute& ); // not supported
void operator=( const XMLAttribute& ); // not supported
void SetName( const char* name );
char* ParseDeep( char* p, bool processEntities );
- mutable StrPair name;
- mutable StrPair value;
- XMLAttribute* next;
- MemPool* memPool;
+ mutable StrPair _name;
+ mutable StrPair _value;
+ XMLAttribute* _next;
+ MemPool* _memPool;
};
@@ -1135,70 +1146,70 @@
QueryIntAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
@endverbatim
*/
- int QueryIntAttribute( const char* name, int* _value ) const {
+ int QueryIntAttribute( const char* name, int* value ) const {
const XMLAttribute* a = FindAttribute( name );
if ( !a ) {
return XML_NO_ATTRIBUTE;
}
- return a->QueryIntValue( _value );
+ return a->QueryIntValue( value );
}
/// See QueryIntAttribute()
- int QueryUnsignedAttribute( const char* name, unsigned int* _value ) const {
+ int QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
const XMLAttribute* a = FindAttribute( name );
if ( !a ) {
return XML_NO_ATTRIBUTE;
}
- return a->QueryUnsignedValue( _value );
+ return a->QueryUnsignedValue( value );
}
/// See QueryIntAttribute()
- int QueryBoolAttribute( const char* name, bool* _value ) const {
+ int QueryBoolAttribute( const char* name, bool* value ) const {
const XMLAttribute* a = FindAttribute( name );
if ( !a ) {
return XML_NO_ATTRIBUTE;
}
- return a->QueryBoolValue( _value );
+ return a->QueryBoolValue( value );
}
/// See QueryIntAttribute()
- int QueryDoubleAttribute( const char* name, double* _value ) const {
+ int QueryDoubleAttribute( const char* name, double* value ) const {
const XMLAttribute* a = FindAttribute( name );
if ( !a ) {
return XML_NO_ATTRIBUTE;
}
- return a->QueryDoubleValue( _value );
+ return a->QueryDoubleValue( value );
}
/// See QueryIntAttribute()
- int QueryFloatAttribute( const char* name, float* _value ) const {
+ int QueryFloatAttribute( const char* name, float* value ) const {
const XMLAttribute* a = FindAttribute( name );
if ( !a ) {
return XML_NO_ATTRIBUTE;
}
- return a->QueryFloatValue( _value );
+ return a->QueryFloatValue( value );
}
/// Sets the named attribute to value.
- void SetAttribute( const char* name, const char* _value ) {
+ void SetAttribute( const char* name, const char* value ) {
XMLAttribute* a = FindOrCreateAttribute( name );
- a->SetAttribute( _value );
+ a->SetAttribute( value );
}
/// Sets the named attribute to value.
- void SetAttribute( const char* name, int _value ) {
+ void SetAttribute( const char* name, int value ) {
XMLAttribute* a = FindOrCreateAttribute( name );
- a->SetAttribute( _value );
+ a->SetAttribute( value );
}
/// Sets the named attribute to value.
- void SetAttribute( const char* name, unsigned _value ) {
+ void SetAttribute( const char* name, unsigned value ) {
XMLAttribute* a = FindOrCreateAttribute( name );
- a->SetAttribute( _value );
+ a->SetAttribute( value );
}
/// Sets the named attribute to value.
- void SetAttribute( const char* name, bool _value ) {
+ void SetAttribute( const char* name, bool value ) {
XMLAttribute* a = FindOrCreateAttribute( name );
- a->SetAttribute( _value );
+ a->SetAttribute( value );
}
/// Sets the named attribute to value.
- void SetAttribute( const char* name, double _value ) {
+ void SetAttribute( const char* name, double value ) {
XMLAttribute* a = FindOrCreateAttribute( name );
- a->SetAttribute( _value );
+ a->SetAttribute( value );
}
/**
@@ -1208,7 +1219,7 @@
/// Return the first attribute in the list.
const XMLAttribute* FirstAttribute() const {
- return rootAttribute;
+ return _rootAttribute;
}
/// Query a specific attribute in the list.
const XMLAttribute* FindAttribute( const char* name ) const;
@@ -1286,7 +1297,7 @@
CLOSING // </foo>
};
int ClosingType() const {
- return closingType;
+ return _closingType;
}
char* ParseDeep( char* p, StrPair* endTag );
virtual XMLNode* ShallowClone( XMLDocument* document ) const;
@@ -1303,11 +1314,11 @@
//void LinkAttribute( XMLAttribute* attrib );
char* ParseAttributes( char* p );
- int closingType;
+ int _closingType;
// The attribute list is ordered; there is no 'lastAttribute'
// because the list needs to be scanned for dupes before adding
// a new attribute.
- XMLAttribute* rootAttribute;
+ XMLAttribute* _rootAttribute;
};
@@ -1382,22 +1393,22 @@
int SaveFile( FILE* fp, bool compact = false );
bool ProcessEntities() const {
- return processEntities;
+ return _processEntities;
}
Whitespace WhitespaceMode() const {
- return whitespace;
+ return _whitespace;
}
/**
Returns true if this document has a leading Byte Order Mark of UTF8.
*/
bool HasBOM() const {
- return writeBOM;
+ return _writeBOM;
}
/** Sets whether to write the BOM when writing the file.
*/
void SetBOM( bool useBOM ) {
- writeBOM = useBOM;
+ _writeBOM = useBOM;
}
/** Return the root element of DOM. Equivalent to FirstChildElement().
@@ -1459,7 +1470,7 @@
XMLDeclaration* NewDeclaration( const char* text=0 );
/**
Create a new Unknown associated with
- this Document. The memory for the object
+ this Document. The memory forthe object
is managed by the Document.
*/
XMLUnknown* NewUnknown( const char* text );
@@ -1469,26 +1480,26 @@
It will be unlinked from the DOM.
*/
void DeleteNode( XMLNode* node ) {
- node->parent->DeleteChild( node );
+ node->_parent->DeleteChild( node );
}
void SetError( int error, const char* str1, const char* str2 );
/// Return true if there was an error parsing the document.
bool Error() const {
- return errorID != XML_NO_ERROR;
+ return _errorID != XML_NO_ERROR;
}
/// Return the errorID.
int ErrorID() const {
- return errorID;
+ return _errorID;
}
/// Return a possibly helpful diagnostic location or string.
const char* GetErrorStr1() const {
- return errorStr1;
+ return _errorStr1;
}
/// Return a possibly helpful secondary diagnostic location or string.
const char* GetErrorStr2() const {
- return errorStr2;
+ return _errorStr2;
}
/// If there is an error, print it to stdout.
void PrintError() const;
@@ -1508,18 +1519,18 @@
void operator=( const XMLDocument& ); // not supported
void InitDocument();
- bool writeBOM;
- bool processEntities;
- int errorID;
- Whitespace whitespace;
- const char* errorStr1;
- const char* errorStr2;
- char* charBuffer;
+ bool _writeBOM;
+ bool _processEntities;
+ int _errorID;
+ Whitespace _whitespace;
+ const char* _errorStr1;
+ const char* _errorStr2;
+ char* _charBuffer;
- MemPoolT< sizeof(XMLElement) > elementPool;
- MemPoolT< sizeof(XMLAttribute) > attributePool;
- MemPoolT< sizeof(XMLText) > textPool;
- MemPoolT< sizeof(XMLComment) > commentPool;
+ MemPoolT< sizeof(XMLElement) > _elementPool;
+ MemPoolT< sizeof(XMLAttribute) > _attributePool;
+ MemPoolT< sizeof(XMLText) > _textPool;
+ MemPoolT< sizeof(XMLComment) > _commentPool;
};
@@ -1582,79 +1593,79 @@
{
public:
/// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
- XMLHandle( XMLNode* _node ) {
- node = _node;
+ XMLHandle( XMLNode* node ) {
+ _node = node;
}
/// Create a handle from a node.
- XMLHandle( XMLNode& _node ) {
- node = &_node;
+ XMLHandle( XMLNode& node ) {
+ _node = &node;
}
/// Copy constructor
XMLHandle( const XMLHandle& ref ) {
- node = ref.node;
+ _node = ref._node;
}
/// Assignment
XMLHandle& operator=( const XMLHandle& ref ) {
- node = ref.node;
+ _node = ref._node;
return *this;
}
/// Get the first child of this handle.
XMLHandle FirstChild() {
- return XMLHandle( node ? node->FirstChild() : 0 );
+ return XMLHandle( _node ? _node->FirstChild() : 0 );
}
/// Get the first child element of this handle.
XMLHandle FirstChildElement( const char* value=0 ) {
- return XMLHandle( node ? node->FirstChildElement( value ) : 0 );
+ return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
}
/// Get the last child of this handle.
XMLHandle LastChild() {
- return XMLHandle( node ? node->LastChild() : 0 );
+ return XMLHandle( _node ? _node->LastChild() : 0 );
}
/// Get the last child element of this handle.
XMLHandle LastChildElement( const char* _value=0 ) {
- return XMLHandle( node ? node->LastChildElement( _value ) : 0 );
+ return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
}
/// Get the previous sibling of this handle.
XMLHandle PreviousSibling() {
- return XMLHandle( node ? node->PreviousSibling() : 0 );
+ return XMLHandle( _node ? _node->PreviousSibling() : 0 );
}
/// Get the previous sibling element of this handle.
XMLHandle PreviousSiblingElement( const char* _value=0 ) {
- return XMLHandle( node ? node->PreviousSiblingElement( _value ) : 0 );
+ return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
}
/// Get the next sibling of this handle.
XMLHandle NextSibling() {
- return XMLHandle( node ? node->NextSibling() : 0 );
+ return XMLHandle( _node ? _node->NextSibling() : 0 );
}
/// Get the next sibling element of this handle.
XMLHandle NextSiblingElement( const char* _value=0 ) {
- return XMLHandle( node ? node->NextSiblingElement( _value ) : 0 );
+ return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
}
/// Safe cast to XMLNode. This can return null.
XMLNode* ToNode() {
- return node;
+ return _node;
}
/// Safe cast to XMLElement. This can return null.
XMLElement* ToElement() {
- return ( ( node && node->ToElement() ) ? node->ToElement() : 0 );
+ return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
}
/// Safe cast to XMLText. This can return null.
XMLText* ToText() {
- return ( ( node && node->ToText() ) ? node->ToText() : 0 );
+ return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
}
/// Safe cast to XMLUnknown. This can return null.
XMLUnknown* ToUnknown() {
- return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 );
+ return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
}
/// Safe cast to XMLDeclaration. This can return null.
XMLDeclaration* ToDeclaration() {
- return ( ( node && node->ToDeclaration() ) ? node->ToDeclaration() : 0 );
+ return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
}
private:
- XMLNode* node;
+ XMLNode* _node;
};
@@ -1665,65 +1676,65 @@
class XMLConstHandle
{
public:
- XMLConstHandle( const XMLNode* _node ) {
- node = _node;
+ XMLConstHandle( const XMLNode* node ) {
+ _node = node;
}
- XMLConstHandle( const XMLNode& _node ) {
- node = &_node;
+ XMLConstHandle( const XMLNode& node ) {
+ _node = &node;
}
XMLConstHandle( const XMLConstHandle& ref ) {
- node = ref.node;
+ _node = ref._node;
}
XMLConstHandle& operator=( const XMLConstHandle& ref ) {
- node = ref.node;
+ _node = ref._node;
return *this;
}
const XMLConstHandle FirstChild() const {
- return XMLConstHandle( node ? node->FirstChild() : 0 );
+ return XMLConstHandle( _node ? _node->FirstChild() : 0 );
}
const XMLConstHandle FirstChildElement( const char* value=0 ) const {
- return XMLConstHandle( node ? node->FirstChildElement( value ) : 0 );
+ return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
}
const XMLConstHandle LastChild() const {
- return XMLConstHandle( node ? node->LastChild() : 0 );
+ return XMLConstHandle( _node ? _node->LastChild() : 0 );
}
const XMLConstHandle LastChildElement( const char* _value=0 ) const {
- return XMLConstHandle( node ? node->LastChildElement( _value ) : 0 );
+ return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
}
const XMLConstHandle PreviousSibling() const {
- return XMLConstHandle( node ? node->PreviousSibling() : 0 );
+ return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
}
const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const {
- return XMLConstHandle( node ? node->PreviousSiblingElement( _value ) : 0 );
+ return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
}
const XMLConstHandle NextSibling() const {
- return XMLConstHandle( node ? node->NextSibling() : 0 );
+ return XMLConstHandle( _node ? _node->NextSibling() : 0 );
}
const XMLConstHandle NextSiblingElement( const char* _value=0 ) const {
- return XMLConstHandle( node ? node->NextSiblingElement( _value ) : 0 );
+ return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
}
const XMLNode* ToNode() const {
- return node;
+ return _node;
}
const XMLElement* ToElement() const {
- return ( ( node && node->ToElement() ) ? node->ToElement() : 0 );
+ return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
}
const XMLText* ToText() const {
- return ( ( node && node->ToText() ) ? node->ToText() : 0 );
+ return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
}
const XMLUnknown* ToUnknown() const {
- return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 );
+ return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
}
const XMLDeclaration* ToDeclaration() const {
- return ( ( node && node->ToDeclaration() ) ? node->ToDeclaration() : 0 );
+ return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
}
private:
- const XMLNode* node;
+ const XMLNode* _node;
};
@@ -1833,7 +1844,7 @@
the XML file in memory.
*/
const char* CStr() const {
- return buffer.Mem();
+ return _buffer.Mem();
}
/**
If in print to memory mode, return the size
@@ -1841,7 +1852,7 @@
includes the terminating null.)
*/
int CStrSize() const {
- return buffer.Size();
+ return _buffer.Size();
}
private:
@@ -1850,25 +1861,25 @@
void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
void Print( const char* format, ... );
- bool elementJustOpened;
- bool firstElement;
- FILE* fp;
- int depth;
- int textDepth;
- bool processEntities;
- bool compactMode;
+ bool _elementJustOpened;
+ bool _firstElement;
+ FILE* _fp;
+ int _depth;
+ int _textDepth;
+ bool _processEntities;
+ bool _compactMode;
enum {
ENTITY_RANGE = 64,
BUF_SIZE = 200
};
- bool entityFlag[ENTITY_RANGE];
- bool restrictedEntityFlag[ENTITY_RANGE];
+ bool _entityFlag[ENTITY_RANGE];
+ bool _restrictedEntityFlag[ENTITY_RANGE];
- DynArray< const char*, 10 > stack;
- DynArray< char, 20 > buffer;
+ DynArray< const char*, 10 > _stack;
+ DynArray< char, 20 > _buffer;
#ifdef _MSC_VER
- DynArray< char, 20 > accumulator;
+ DynArray< char, 20 > _accumulator;
#endif
};