/*www.sourceforge.net/projects/tinyxmlOriginal code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)This software is provided 'as-is', without any express or impliedwarranty. In no event will the authors be held liable for anydamages arising from the use of this software.Permission is granted to anyone to use this software for anypurpose, including commercial applications, and to alter it andredistribute it freely, subject to the following restrictions:1. The origin of this software must not be misrepresented; you mustnot claim that you wrote the original software. If you use thissoftware in a product, an acknowledgment in the product documentationwould be appreciated but is not required.2. Altered source versions must be plainly marked as such, andmust not be misrepresented as being the original software.3. This notice may not be removed or altered from any sourcedistribution.*/#include <ctype.h>#include "tinyxmlA.h"#ifdef TIXMLA_USE_STL#include <sstream>#endifbool TiXmlBaseA::condenseWhiteSpace = true;void TiXmlBaseA::PutString( const TIXMLA_STRING& str, TIXMLA_OSTREAM* stream ){	TIXMLA_STRING buffer;	PutString( str, &buffer );	(*stream) << buffer;}void TiXmlBaseA::PutString( const TIXMLA_STRING& str, TIXMLA_STRING* outString ){	int i=0;	while( i<(int)str.length() )	{		int c = str[i];		if (    c == '&' 		     && i < ( (int)str.length() - 2 )			 && str[i+1] == '#'			 && str[i+2] == 'x' )		{			// Hexadecimal character reference.			// Pass through unchanged.			// &#xA9;	-- copyright symbol, for example.			while ( i<(int)str.length() )			{				outString->append( str.c_str() + i, 1 );				++i;				if ( str[i] == ';' )					break;			}		}		else if ( c == '&' )		{			outString->append( entity[0].str, entity[0].strLength );			++i;		}		else if ( c == '<' )		{			outString->append( entity[1].str, entity[1].strLength );			++i;		}		else if ( c == '>' )		{			outString->append( entity[2].str, entity[2].strLength );			++i;		}		else if ( c == '\"' )		{			outString->append( entity[3].str, entity[3].strLength );			++i;		}		else if ( c == '\'' )		{			outString->append( entity[4].str, entity[4].strLength );			++i;		}		else if ( c < 32 || c > 126 )		{			// Easy pass at non-alpha/numeric/symbol			// 127 is the delete key. Below 32 is symbolic.			char buf[ 32 ];			sprintf( buf, "&#x%02X;", (unsigned) ( c & 0xff ) );			outString->append( buf, strlen( buf ) );			++i;		}		else		{			char realc = (char) c;			outString->append( &realc, 1 );			++i;		}	}}// <-- Strange class for a bug fix. Search for STL_STRING_BUGTiXmlBaseA::StringToBuffer::StringToBuffer( const TIXMLA_STRING& str ){	buffer = new char[ str.length()+1 ];	if ( buffer )	{		strcpy( buffer, str.c_str() );	}}TiXmlBaseA::StringToBuffer::~StringToBuffer(){	delete [] buffer;}// End strange bug fix. -->TiXmlNodeA::TiXmlNodeA( NodeType _type ){	parent = 0;	type = _type;	firstChild = 0;	lastChild = 0;	prev = 0;	next = 0;	userData = 0;}TiXmlNodeA::~TiXmlNodeA(){	TiXmlNodeA* node = firstChild;	TiXmlNodeA* temp = 0;	while ( node )	{		temp = node;		node = node->next;		delete temp;	}	}void TiXmlNodeA::Clear(){	TiXmlNodeA* node = firstChild;	TiXmlNodeA* temp = 0;	while ( node )	{		temp = node;		node = node->next;		delete temp;	}		firstChild = 0;	lastChild = 0;}TiXmlNodeA* TiXmlNodeA::LinkEndChild( TiXmlNodeA* node ){	node->parent = this;	node->prev = lastChild;	node->next = 0;	if ( lastChild )		lastChild->next = node;	else		firstChild = node;			// it was an empty list.	lastChild = node;	return node;}TiXmlNodeA* TiXmlNodeA::InsertEndChild( const TiXmlNodeA& addThis ){	TiXmlNodeA* node = addThis.Clone();	if ( !node )		return 0;	return LinkEndChild( node );}TiXmlNodeA* TiXmlNodeA::InsertBeforeChild( TiXmlNodeA* beforeThis, const TiXmlNodeA& addThis ){		if ( !beforeThis || beforeThis->parent != this )		return 0;	TiXmlNodeA* node = addThis.Clone();	if ( !node )		return 0;	node->parent = this;	node->next = beforeThis;	node->prev = beforeThis->prev;	if ( beforeThis->prev )	{		beforeThis->prev->next = node;	}	else	{		assert( firstChild == beforeThis );		firstChild = node;	}	beforeThis->prev = node;	return node;}TiXmlNodeA* TiXmlNodeA::InsertAfterChild( TiXmlNodeA* afterThis, const TiXmlNodeA& addThis ){	if ( !afterThis || afterThis->parent != this )		return 0;	TiXmlNodeA* node = addThis.Clone();	if ( !node )		return 0;	node->parent = this;	node->prev = afterThis;	node->next = afterThis->next;	if ( afterThis->next )	{		afterThis->next->prev = node;	}	else	{		assert( lastChild == afterThis );		lastChild = node;	}	afterThis->next = node;	return node;}TiXmlNodeA* TiXmlNodeA::ReplaceChild( TiXmlNodeA* replaceThis, const TiXmlNodeA& withThis ){	if ( replaceThis->parent != this )		return 0;	TiXmlNodeA* node = withThis.Clone();	if ( !node )		return 0;	node->next = replaceThis->next;	node->prev = replaceThis->prev;	if ( replaceThis->next )		replaceThis->next->prev = node;	else		lastChild = node;	if ( replaceThis->prev )		replaceThis->prev->next = node;	else		firstChild = node;	delete replaceThis;	node->parent = this;	return node;}bool TiXmlNodeA::RemoveChild( TiXmlNodeA* removeThis ){	if ( removeThis->parent != this )	{			assert( 0 );		return false;	}	if ( removeThis->next )		removeThis->next->prev = removeThis->prev;	else		lastChild = removeThis->prev;	if ( removeThis->prev )		removeThis->prev->next = removeThis->next;	else		firstChild = removeThis->next;	delete removeThis;	return true;}TiXmlNodeA* TiXmlNodeA::FirstChild( const char * _value ) const{	TiXmlNodeA* node;	for ( node = firstChild; node; node = node->next )	{		if ( node->SValue() == TIXMLA_STRING( _value ))			return node;	}	return 0;}TiXmlNodeA* TiXmlNodeA::LastChild( const char * _value ) const{	TiXmlNodeA* node;	for ( node = lastChild; node; node = node->prev )	{		if ( node->SValue() == TIXMLA_STRING (_value))			return node;	}	return 0;}TiXmlNodeA* TiXmlNodeA::IterateChildren( TiXmlNodeA* previous ) const{	if ( !previous )	{		return FirstChild();	}	else	{		assert( previous->parent == this );		return previous->NextSibling();	}}TiXmlNodeA* TiXmlNodeA::IterateChildren( const char * val, TiXmlNodeA* previous ) const{	if ( !previous )	{		return FirstChild( val );	}	else	{		assert( previous->parent == this );		return previous->NextSibling( val );	}}TiXmlNodeA* TiXmlNodeA::NextSibling( const char * _value ) const{	TiXmlNodeA* node;	for ( node = next; node; node = node->next )	{		if ( node->SValue() == TIXMLA_STRING (_value))			return node;	}	return 0;}TiXmlNodeA* TiXmlNodeA::PreviousSibling( const char * _value ) const{	TiXmlNodeA* node;	for ( node = prev; node; node = node->prev )	{		if ( node->SValue() == TIXMLA_STRING (_value))			return node;	}	return 0;}void TiXmlElementA::RemoveAttribute( const char * name ){	TiXmlAttributeA* node = attributeSet.Find( name );	if ( node )	{		attributeSet.Remove( node );		delete node;	}}TiXmlElementA* TiXmlNodeA::FirstChildElement() const{	TiXmlNodeA* node;	for (	node = FirstChild();	node;	node = node->NextSibling() )	{		if ( node->ToElement() )			return node->ToElement();	}	return 0;}TiXmlElementA* TiXmlNodeA::FirstChildElement( const char * _value ) const{	TiXmlNodeA* node;	for (	node = FirstChild( _value );	node;	node = node->NextSibling( _value ) )	{		if ( node->ToElement() )			return node->ToElement();	}	return 0;}TiXmlElementA* TiXmlNodeA::NextSiblingElement() const{	TiXmlNodeA* node;	for (	node = NextSibling();	node;	node = node->NextSibling() )	{		if ( node->ToElement() )			return node->ToElement();	}	return 0;}TiXmlElementA* TiXmlNodeA::NextSiblingElement( const char * _value ) const{	TiXmlNodeA* node;	for (	node = NextSibling( _value );	node;	node = node->NextSibling( _value ) )	{		if ( node->ToElement() )			return node->ToElement();	}	return 0;}TiXmlDocumentA* TiXmlNodeA::GetDocument() const{	const TiXmlNodeA* node;	for( node = this; node; node = node->parent )	{		if ( node->ToDocument() )			return node->ToDocument();	}	return 0;}TiXmlElementA::TiXmlElementA (const char * _value): TiXmlNodeA( TiXmlNodeA::ELEMENT ){	firstChild = lastChild = 0;	value = _value;}TiXmlElementA::~TiXmlElementA(){	while( attributeSet.First() )	{		TiXmlAttributeA* node = attributeSet.First();		attributeSet.Remove( node );		delete node;	}}const char * TiXmlElementA::Attribute( const char * name ) const{	TiXmlAttributeA* node = attributeSet.Find( name );	if ( node )		return node->Value();	return 0;}const char * TiXmlElementA::Attribute( const char * name, int* i ) const{	const char * s = Attribute( name );	if ( i )	{		if ( s )			*i = atoi( s );		else			*i = 0;	}	return s;}const char * TiXmlElementA::Attribute( const char * name, double* d ) const{	const char * s = Attribute( name );	if ( d )	{		if ( s )			*d = atof( s );		else			*d = 0;	}	return s;}int TiXmlElementA::QueryIntAttribute( const char* name, int* ival ) const{	TiXmlAttributeA* node = attributeSet.Find( name );	if ( !node )		return TIXMLA_NO_ATTRIBUTE;	return node->QueryIntValue( ival );}int TiXmlElementA::QueryDoubleAttribute( const char* name, double* dval ) const{	TiXmlAttributeA* node = attributeSet.Find( name );	if ( !node )		return TIXMLA_NO_ATTRIBUTE;	return node->QueryDoubleValue( dval );}void TiXmlElementA::SetAttribute( const char * name, int val ){		char buf[64];	sprintf( buf, "%d", val );	SetAttribute( name, buf );}void TiXmlElementA::SetAttribute( const char * name, const char * _value ){	TiXmlAttributeA* node = attributeSet.Find( name );	if ( node )	{		node->SetValue( _value );		return;	}	TiXmlAttributeA* attrib = new TiXmlAttributeA( name, _value );	if ( attrib )	{		attributeSet.Add( attrib );	}	else	{		TiXmlDocumentA* document = GetDocument();		if ( document ) document->SetError( TIXMLA_ERROR_OUT_OF_MEMORY, 0, 0 );	}}void TiXmlElementA::Print( FILE* cfile, int depth ) const{	int i;	for ( i=0; i<depth; i++ )	{		fprintf( cfile, "    " );	}	fprintf( cfile, "<%s", value.c_str() );	TiXmlAttributeA* attrib;	for ( attrib = attributeSet.First(); attrib; attrib = attrib->Next() )	{		fprintf( cfile, " " );		attrib->Print( cfile, depth );	}	// There are 3 different formatting approaches:	// 1) An element without children is printed as a <foo /> node	// 2) An element with only a text child is printed as <foo> text </foo>	// 3) An element with children is printed on multiple lines.	TiXmlNodeA* node;	if ( !firstChild )	{		fprintf( cfile, " />" );	}	else if ( firstChild == lastChild && firstChild->ToText() )	{		fprintf( cfile, ">" );		firstChild->Print( cfile, depth + 1 );		fprintf( cfile, "</%s>", value.c_str() );	}	else	{		fprintf( cfile, ">" );		for ( node = firstChild; node; node=node->NextSibling() )		{			if ( !node->ToText() )			{				fprintf( cfile, "\n" );			}			node->Print( cfile, depth+1 );		}		fprintf( cfile, "\n" );		for( i=0; i<depth; ++i )		fprintf( cfile, "    " );		fprintf( cfile, "</%s>", value.c_str() );	}}void TiXmlElementA::StreamOut( TIXMLA_OSTREAM * stream ) const{	(*stream) << "<" << value;	TiXmlAttributeA* attrib;	for ( attrib = attributeSet.First(); attrib; attrib = attrib->Next() )	{			(*stream) << " ";		attrib->StreamOut( stream );	}	// If this node has children, give it a closing tag. Else	// make it an empty tag.	TiXmlNodeA* node;	if ( firstChild )	{ 				(*stream) << ">";		for ( node = firstChild; node; node=node->NextSibling() )		{			node->StreamOut( stream );		}		(*stream) << "</" << value << ">";	}	else	{		(*stream) << " />";	}}TiXmlNodeA* TiXmlElementA::Clone() const{	TiXmlElementA* clone = new TiXmlElementA( Value() );	if ( !clone )		return 0;	CopyToClone( clone );	// Clone the attributes, then clone the children.	TiXmlAttributeA* attribute = 0;	for(	attribute = attributeSet.First();	attribute;	attribute = attribute->Next() )	{		clone->SetAttribute( attribute->Name(), attribute->Value() );	}	TiXmlNodeA* node = 0;	for ( node = firstChild; node; node = node->NextSibling() )	{		clone->LinkEndChild( node->Clone() );	}