#include "tinyxml2.h"

#include <new> // yes, this one new style header, is in the Android SDK.

# ifdef ANDROID_NDK

# include <stddef.h>

#else

# include <cstddef>

#endif

static const char LINE_FEED = (char)0x0a; // all line endings are normalized to LF

static const char LF = LINE_FEED;

static const char CARRIAGE_RETURN = (char)0x0d; // CR gets filtered out

static const char CR = CARRIAGE_RETURN;

static const char SINGLE_QUOTE = '\'';

static const char DOUBLE_QUOTE = '\"';

static const unsigned char TIXML_UTF_LEAD_0 = 0xefU;

static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;

static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;

namespace tinyxml2

{

struct Entity {

};

static const int NUM_ENTITIES = 5;

static const Entity entities[NUM_ENTITIES] = {

{ "quot", 4, DOUBLE_QUOTE },

{ "amp", 3, '&' },

{ "apos", 4, SINGLE_QUOTE },

{ "lt", 2, '<' },

{ "gt", 2, '>' }

};

StrPair::~StrPair()

{

Reset();

}

void StrPair::Reset()

}

void StrPair::SetStr( const char* str, int flags )

}

char* StrPair::ParseText( char* p, const char* endTag, int strFlags )

{

TIXMLASSERT( endTag && *endTag );

char* start = p;

char endChar = *endTag;

size_t length = strlen( endTag );

// Inner loop of text parsing.

while ( *p ) {

if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {

Set( start, p, strFlags );

return p + length;

}

++p;

}

return 0;

}

char* StrPair::ParseName( char* p )

{

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

return 0;

}

char* const start = p;

while( *p && ( p == start ? XMLUtil::IsNameStartChar( *p ) : XMLUtil::IsNameChar( *p ) )) {

++p;

}

if ( p > start ) {

Set( start, p, 0 );

return p;

}

return 0;

}

void StrPair::CollapseWhitespace()

}

const char* StrPair::GetStr()

{

if ( _flags & NEEDS_FLUSH ) {

*_end = 0;

_flags ^= NEEDS_FLUSH;

if ( _flags ) {

char* p = _start; // the read pointer

char* q = _start; // the write pointer

while( p < _end ) {

if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {

// CR-LF pair becomes LF

// CR alone becomes LF

// LF-CR becomes LF

if ( *(p+1) == LF ) {

p += 2;

}

else {

++p;

}

*q++ = LF;

}

else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {

if ( *(p+1) == CR ) {

p += 2;

}

else {

++p;

}

*q++ = LF;

}

else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {

// Entities handled by tinyXML2:

// - special entities in the entity table [in/out]

// - numeric character reference [in]

// &#20013; or &#x4e2d;

if ( *(p+1) == '#' ) {

const int buflen = 10;

char buf[buflen] = { 0 };

int len = 0;

p = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );

TIXMLASSERT( 0 <= len && len <= buflen );

TIXMLASSERT( q + len <= p );

memcpy( q, buf, len );

q += len;

}

else {

int i=0;

for(; i<NUM_ENTITIES; ++i ) {

const Entity& entity = entities[i];

if ( strncmp( p + 1, entity.pattern, entity.length ) == 0

&& *( p + entity.length + 1 ) == ';' ) {

// Found an entity - convert.

*q = entity.value;

++q;

p += entity.length + 2;

break;

}

}

if ( i == NUM_ENTITIES ) {

// fixme: treat as error?

++p;

++q;

}

}

}

else {

*q = *p;

++p;

++q;

}

}

*q = 0;

}

// The loop below has plenty going on, and this

// is a less useful mode. Break it out.

if ( _flags & COLLAPSE_WHITESPACE ) {

CollapseWhitespace();

}

_flags = (_flags & NEEDS_DELETE);

}

return _start;

}

const char* XMLUtil::ReadBOM( const char* p, bool* bom )

{

*bom = false;

const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);

// Check for BOM:

if ( *(pu+0) == TIXML_UTF_LEAD_0

&& *(pu+1) == TIXML_UTF_LEAD_1

&& *(pu+2) == TIXML_UTF_LEAD_2 ) {

*bom = true;

p += 3;

}

return p;

}

void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )

}

const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )

{

// Presume an entity, and pull it out.

*length = 0;

if ( *(p+1) == '#' && *(p+2) ) {

unsigned long ucs = 0;

ptrdiff_t delta = 0;

unsigned mult = 1;

if ( *(p+2) == 'x' ) {

// Hexadecimal.

if ( !*(p+3) ) {

return 0;

}

const char* q = p+3;

q = strchr( q, ';' );

if ( !q || !*q ) {

return 0;

}

delta = q-p;

--q;

while ( *q != 'x' ) {

if ( *q >= '0' && *q <= '9' ) {

ucs += mult * (*q - '0');

}

else if ( *q >= 'a' && *q <= 'f' ) {

ucs += mult * (*q - 'a' + 10);

}

else if ( *q >= 'A' && *q <= 'F' ) {

ucs += mult * (*q - 'A' + 10 );

}

else {

return 0;

}

mult *= 16;

--q;

}

}

else {

// Decimal.

if ( !*(p+2) ) {

return 0;

}

const char* q = p+2;

q = strchr( q, ';' );

if ( !q || !*q ) {

return 0;

}

delta = q-p;

--q;

while ( *q != '#' ) {

if ( *q >= '0' && *q <= '9' ) {

ucs += mult * (*q - '0');

}

else {

return 0;

}

mult *= 10;

--q;

}

}

// convert the UCS to UTF-8

ConvertUTF32ToUTF8( ucs, value, length );

return p + delta + 1;

}

return p+1;

}

void XMLUtil::ToStr( int v, char* buffer, int bufferSize )

{

TIXML_SNPRINTF( buffer, bufferSize, "%d", v );

}

void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )

{

TIXML_SNPRINTF( buffer, bufferSize, "%u", v );

}

void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )

{

TIXML_SNPRINTF( buffer, bufferSize, "%d", v ? 1 : 0 );

}

void XMLUtil::ToStr( float v, char* buffer, int bufferSize )

{

TIXML_SNPRINTF( buffer, bufferSize, "%.8g", v );

}

void XMLUtil::ToStr( double v, char* buffer, int bufferSize )

{

TIXML_SNPRINTF( buffer, bufferSize, "%.17g", v );

}

bool XMLUtil::ToInt( const char* str, int* value )

}

bool XMLUtil::ToUnsigned( const char* str, unsigned *value )

}

bool XMLUtil::ToBool( const char* str, bool* value )

}

bool XMLUtil::ToFloat( const char* str, float* value )

}

bool XMLUtil::ToDouble( const char* str, double* value )

}

char* XMLDocument::Identify( char* p, XMLNode** node )

{

char* const start = p;

p = XMLUtil::SkipWhiteSpace( p );

if( !p || !*p ) {

return p;

}

// What is this thing?

// These strings define the matching patters:

static const char* xmlHeader = { "<?" };

static const char* commentHeader = { "<!--" };

static const char* dtdHeader = { "<!" };

static const char* cdataHeader = { "<![CDATA[" };

static const char* elementHeader = { "<" }; // and a header for everything else; check last.

static const int xmlHeaderLen = 2;

static const int commentHeaderLen = 4;

static const int dtdHeaderLen = 2;

static const int cdataHeaderLen = 9;

static const int elementHeaderLen = 1;

#if defined(_MSC_VER)

#pragma warning ( push )

#pragma warning ( disable : 4127 )

#endif

TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) ); // use same memory pool

TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) ); // use same memory pool

#if defined(_MSC_VER)

#pragma warning (pop)

#endif

XMLNode* returnNode = 0;

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

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;

p += commentHeaderLen;

}

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

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

returnNode = text;

returnNode->_memPool = &_textPool;

p += cdataHeaderLen;

text->SetCData( true );

}

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

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;

p += elementHeaderLen;

}

else {

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

returnNode->_memPool = &_textPool;

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

}

*node = returnNode;

return p;

}

bool XMLDocument::Accept( XMLVisitor* visitor ) const

}

XMLNode::XMLNode( XMLDocument* doc ) :

}

XMLNode::~XMLNode()

{

DeleteChildren();

if ( _parent ) {

_parent->Unlink( this );

}

}

const char* XMLNode::Value() const

{

return _value.GetStr();

}

void XMLNode::SetValue( const char* str, bool staticMem )

}

void XMLNode::DeleteChildren()

}

void XMLNode::Unlink( XMLNode* child )

}

void XMLNode::DeleteChild( XMLNode* node )

}

XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )

{

if (addThis->_document != _document)

return 0;

if (addThis->_parent)

addThis->_parent->Unlink( addThis );

else

addThis->_memPool->SetTracked();

if ( _lastChild ) {

TIXMLASSERT( _firstChild );

TIXMLASSERT( _lastChild->_next == 0 );

_lastChild->_next = addThis;

addThis->_prev = _lastChild;

_lastChild = addThis;

addThis->_next = 0;

}

else {

TIXMLASSERT( _firstChild == 0 );

_firstChild = _lastChild = addThis;

addThis->_prev = 0;

addThis->_next = 0;

}

addThis->_parent = this;

return addThis;

}

XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )

{

if (addThis->_document != _document)

return 0;

if (addThis->_parent)

addThis->_parent->Unlink( addThis );

else

addThis->_memPool->SetTracked();

if ( _firstChild ) {

TIXMLASSERT( _lastChild );

TIXMLASSERT( _firstChild->_prev == 0 );

_firstChild->_prev = addThis;

addThis->_next = _firstChild;

_firstChild = addThis;

addThis->_prev = 0;

}

else {

TIXMLASSERT( _lastChild == 0 );

_firstChild = _lastChild = addThis;

addThis->_prev = 0;

addThis->_next = 0;

}

addThis->_parent = this;

return addThis;

}

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

{

if (addThis->_document != _document)

return 0;

TIXMLASSERT( afterThis->_parent == this );

if ( afterThis->_parent != this ) {

return 0;

}

if ( afterThis->_next == 0 ) {

// The last node or the only node.

return InsertEndChild( addThis );

}

if (addThis->_parent)

addThis->_parent->Unlink( addThis );

else

addThis->_memPool->SetTracked();

addThis->_prev = afterThis;

addThis->_next = afterThis->_next;

afterThis->_next->_prev = addThis;

afterThis->_next = addThis;

addThis->_parent = this;

return addThis;

}

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

{

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

XMLElement* element = node->ToElement();

if ( element ) {

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

return element;

}

}

}

return 0;

}

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

{

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

XMLElement* element = node->ToElement();

if ( element ) {

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

return element;

}

}

}

return 0;

}

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

{

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

const XMLElement* element = node->ToElement();

if ( element

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

return element;

}

}

return 0;

}

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

{

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

const XMLElement* element = node->ToElement();

if ( element

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

return element;

}

}

return 0;

}

char* XMLNode::ParseDeep( char* p, StrPair* parentEnd )

{

// This is a recursive method, but thinking about it "at the current level"

// it is a pretty simple flat list:

// <foo/>

// <!-- comment -->

//

// With a special case:

// <foo>

// </foo>

// <!-- comment -->

//

// Where the closing element (/foo) *must* be the next thing after the opening

// element, and the names must match. BUT the tricky bit is that the closing

// element will be read by the child.

//

// 'endTag' is the end tag for this node, it is returned by a call to a child.

// 'parentEnd' is the end tag for the parent, which is filled in and returned.

while( p && *p ) {

XMLNode* node = 0;

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

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

break;

}

StrPair endTag;

p = node->ParseDeep( p, &endTag );

if ( !p ) {

DeleteNode( node );

node = 0;

if ( !_document->Error() ) {

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

}

break;

}

XMLElement* ele = node->ToElement();

// We read the end tag. Return it to the parent.

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

if ( parentEnd ) {

*parentEnd = ele->_value;

}

node->_memPool->SetTracked(); // created and then immediately deleted.

DeleteNode( node );

return p;

}

// Handle an end tag returned to this level.

// And handle a bunch of annoying errors.

if ( ele ) {

bool mismatch = false;

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

mismatch = true;

}

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

mismatch = true;

}

else if ( !endTag.Empty() ) {

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

mismatch = true;

}

}

if ( mismatch ) {

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

p = 0;

}

}

if ( p == 0 ) {

DeleteNode( node );

node = 0;

}

if ( node ) {

this->InsertEndChild( node );

}

}

return 0;

}

void XMLNode::DeleteNode( XMLNode* node )

}

char* XMLText::ParseDeep( char* p, StrPair* )

{

const char* start = p;

if ( this->CData() ) {

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

if ( !p ) {

_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 ) {

flags |= StrPair::COLLAPSE_WHITESPACE;

}

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

if ( !p ) {

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

}

if ( p && *p ) {

return p-1;

}

}

return 0;

}

XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const

{

if ( !doc ) {

doc = _document;

}

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

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

return text;

}

bool XMLText::ShallowEqual( const XMLNode* compare ) const

}

bool XMLText::Accept( XMLVisitor* visitor ) const

{

return visitor->Visit( *this );

}

XMLComment::XMLComment( XMLDocument* doc ) : XMLNode( doc )

{

}

XMLComment::~XMLComment()

{

}

char* XMLComment::ParseDeep( char* p, StrPair* )

{

// Comment parses as text.

const char* start = p;

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

if ( p == 0 ) {

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

}

return p;

}

XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const

{

if ( !doc ) {

doc = _document;

}

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

return comment;

}

bool XMLComment::ShallowEqual( const XMLNode* compare ) const

}

bool XMLComment::Accept( XMLVisitor* visitor ) const

{

return visitor->Visit( *this );

}

XMLDeclaration::XMLDeclaration( XMLDocument* doc ) : XMLNode( doc )

{

}

XMLDeclaration::~XMLDeclaration()

{

//printf( "~XMLDeclaration\n" );

}

char* XMLDeclaration::ParseDeep( char* p, StrPair* )

{

// Declaration parses as text.

const char* start = p;

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

if ( p == 0 ) {

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

}

return p;

}

XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const