#include "tinyxml2.h"

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

#if defined(ANDROID_NDK) || defined(__QNXNTO__)

# include <stddef.h>

# include <stdarg.h>

#else

# include <cstddef>

# include <cstdarg>

#endif

#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)

// Microsoft Visual Studio, version 2005 and higher. Not WinCE.

/*int _snprintf_s(

static inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )

}

static inline int TIXML_VSNPRINTF( char* buffer, size_t size, const char* format, va_list va )

}

#define TIXML_VSCPRINTF _vscprintf

#define TIXML_SSCANF sscanf_s

#elif defined _MSC_VER

// Microsoft Visual Studio 2003 and earlier or WinCE

#define TIXML_SNPRINTF _snprintf

#define TIXML_VSNPRINTF _vsnprintf

#define TIXML_SSCANF sscanf

#if (_MSC_VER < 1400 ) && (!defined WINCE)

// Microsoft Visual Studio 2003 and not WinCE.

#define TIXML_VSCPRINTF _vscprintf // VS2003's C runtime has this, but VC6 C runtime or WinCE SDK doesn't have.

#else

// Microsoft Visual Studio 2003 and earlier or WinCE.

static inline int TIXML_VSCPRINTF( const char* format, va_list va )

}

#endif

#else

// GCC version 3 and higher

//#warning( "Using sn* functions." )

#define TIXML_SNPRINTF snprintf

#define TIXML_VSNPRINTF vsnprintf

static inline int TIXML_VSCPRINTF( const char* format, va_list va )

}

#define TIXML_SSCANF sscanf

#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::TransferTo( StrPair* other )

}

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;

}

if ( !XMLUtil::IsNameStartChar( *p ) ) {

return 0;

}

char* const start = p;

++p;

while ( *p && XMLUtil::IsNameChar( *p ) ) {

++p;

}

Set( start, p, 0 );

return p;

}

void StrPair::CollapseWhitespace()

}

const char* StrPair::GetStr()

{

TIXMLASSERT( _start );

TIXMLASSERT( _end );

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;

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

if ( adjusted == 0 ) {

*q = *p;

++p;

++q;

}

else {

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

TIXMLASSERT( q + len <= adjusted );

p = adjusted;

memcpy( q, buf, len );

q += len;

}

}

else {

bool entityFound = false;

for( int i = 0; 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;

entityFound = true;

break;

}

}

if ( !entityFound ) {

// 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 & NEEDS_WHITESPACE_COLLAPSING ) {

CollapseWhitespace();

}

_flags = (_flags & NEEDS_DELETE);

}

TIXMLASSERT( _start );

return _start;

}

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

{

TIXMLASSERT( p );

TIXMLASSERT( 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;

}

TIXMLASSERT( p );

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;

TIXMLASSERT( sizeof( ucs ) >= 4 );

ptrdiff_t delta = 0;

unsigned mult = 1;

static const char SEMICOLON = ';';

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

// Hexadecimal.

const char* q = p+3;

if ( !(*q) ) {

return 0;

}

q = strchr( q, SEMICOLON );

if ( !q ) {

return 0;

}

TIXMLASSERT( *q == SEMICOLON );

delta = q-p;

--q;

while ( *q != 'x' ) {

unsigned int digit = 0;

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

digit = *q - '0';

}

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

digit = *q - 'a' + 10;

}

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

digit = *q - 'A' + 10;

}

else {

return 0;

}

TIXMLASSERT( digit >= 0 && digit < 16);

TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );

const unsigned int digitScaled = mult * digit;

TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );

ucs += digitScaled;

TIXMLASSERT( mult <= UINT_MAX / 16 );

mult *= 16;

--q;

}

}

else {

// Decimal.

const char* q = p+2;

if ( !(*q) ) {

return 0;

}

q = strchr( q, SEMICOLON );

if ( !q ) {

return 0;

}

TIXMLASSERT( *q == SEMICOLON );

delta = q-p;

--q;

while ( *q != '#' ) {

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

const unsigned int digit = *q - '0';

TIXMLASSERT( digit >= 0 && digit < 10);

TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );

const unsigned int digitScaled = mult * digit;

TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );

ucs += digitScaled;

}

else {

return 0;

}

TIXMLASSERT( mult <= UINT_MAX / 10 );

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 )

{

TIXMLASSERT( node );

TIXMLASSERT( p );

char* const start = p;

p = XMLUtil::SkipWhiteSpace( p );

if( !*p ) {

*node = 0;

TIXMLASSERT( p );

return p;

}

// These strings define the matching patterns:

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

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

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

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

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 cdataHeaderLen = 9;

static const int dtdHeaderLen = 2;

static const int elementHeaderLen = 1;

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

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

XMLNode* returnNode = 0;

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

TIXMLASSERT( sizeof( XMLDeclaration ) == _commentPool.ItemSize() );

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

returnNode->_memPool = &_commentPool;

p += xmlHeaderLen;

}

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

TIXMLASSERT( sizeof( XMLComment ) == _commentPool.ItemSize() );

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

returnNode->_memPool = &_commentPool;

p += commentHeaderLen;

}

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

TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );

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

returnNode = text;

returnNode->_memPool = &_textPool;

p += cdataHeaderLen;

text->SetCData( true );

}

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

TIXMLASSERT( sizeof( XMLUnknown ) == _commentPool.ItemSize() );

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

returnNode->_memPool = &_commentPool;

p += dtdHeaderLen;

}

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

TIXMLASSERT( sizeof( XMLElement ) == _elementPool.ItemSize() );

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

returnNode->_memPool = &_elementPool;

p += elementHeaderLen;

}

else {

TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );

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

returnNode->_memPool = &_textPool;

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

}

TIXMLASSERT( returnNode );

TIXMLASSERT( p );

*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

{

// Catch an edge case: XMLDocuments don't have a a Value. Carefully return nullptr.

if ( this->ToDocument() )

return 0;

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 )

{

TIXMLASSERT( addThis );

if ( addThis->_document != _document ) {

TIXMLASSERT( false );

return 0;

}

InsertChildPreamble( addThis );

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 )

{

TIXMLASSERT( addThis );

if ( addThis->_document != _document ) {

TIXMLASSERT( false );

return 0;

}

InsertChildPreamble( addThis );

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 )

{

TIXMLASSERT( addThis );

if ( addThis->_document != _document ) {

TIXMLASSERT( false );

return 0;

}

TIXMLASSERT( afterThis );

if ( afterThis->_parent != this ) {

TIXMLASSERT( false );

return 0;

}

if ( afterThis->_next == 0 ) {

// The last node or the only node.

return InsertEndChild( addThis );

}

InsertChildPreamble( addThis );

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* name ) const

{

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

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

if ( element ) {

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

return element;

}

}

}

return 0;

}

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

{

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

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

if ( element ) {

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

return element;

}

}

}

return 0;

}

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

{

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

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

if ( element

&& (!name || XMLUtil::StringEqual( name, element->Name() ))) {

return element;

}

}

return 0;

}

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

{

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

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

if ( element

&& (!name || XMLUtil::StringEqual( name, element->Name() ))) {

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 ( node == 0 ) {

break;

}

StrPair endTag;

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

if ( !p ) {

DeleteNode( node );

if ( !_document->Error() ) {

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

}

break;

}

XMLDeclaration* decl = node->ToDeclaration();

if ( decl ) {

// A declaration can only be the first child of a document.

// Set error, if document already has children.

if ( !_document->NoChildren() ) {

_document->SetError( XML_ERROR_PARSING_DECLARATION, decl->Value(), 0);

DeleteNode( decl );

break;

}

}

XMLElement* ele = node->ToElement();

if ( ele ) {

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

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

if ( parentEnd ) {

ele->_value.TransferTo( parentEnd );

}

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.

bool mismatch = false;

if ( endTag.Empty() ) {

if ( ele->ClosingType() == XMLElement::OPEN ) {

mismatch = true;

}

}

else {

if ( ele->ClosingType() != XMLElement::OPEN ) {

mismatch = true;

}