#include "tinyxml2.h"

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

#if defined(ANDROID_NDK) || defined(__BORLANDC__) || 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, int* curLineNumPtr )

{

TIXMLASSERT( p );

TIXMLASSERT( endTag && *endTag );

TIXMLASSERT(curLineNumPtr);

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;

} else if (*p == '\n') {

++(*curLineNumPtr);

}

++p;

TIXMLASSERT( 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 ) {

const 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;

++q;

}

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

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

p += 2;

}

else {

++p;

}

*q = LF;

++q;

}

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::writeBoolTrue = "true";

const char* XMLUtil::writeBoolFalse = "false";

void XMLUtil::SetBoolSerialization(const char* writeTrue, const char* writeFalse)

}

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 < 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 < 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, "%s", v ? writeBoolTrue : writeBoolFalse);

}

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 );

}

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

}

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 )

}

bool XMLUtil::ToInt64(const char* str, int64_t* value)

}

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

{

TIXMLASSERT( node );

TIXMLASSERT( p );

char* const start = p;

int const startLine = _parseCurLineNum;

p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );

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

returnNode = CreateUnlinkedNode<XMLDeclaration>( _commentPool );

returnNode->_parseLineNum = _parseCurLineNum;

p += xmlHeaderLen;

}

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

returnNode = CreateUnlinkedNode<XMLComment>( _commentPool );

returnNode->_parseLineNum = _parseCurLineNum;

p += commentHeaderLen;

}

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

XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );

returnNode = text;

returnNode->_parseLineNum = _parseCurLineNum;

p += cdataHeaderLen;

text->SetCData( true );

}

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

returnNode = CreateUnlinkedNode<XMLUnknown>( _commentPool );

returnNode->_parseLineNum = _parseCurLineNum;

p += dtdHeaderLen;

}

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

returnNode = CreateUnlinkedNode<XMLElement>( _elementPool );

returnNode->_parseLineNum = _parseCurLineNum;

p += elementHeaderLen;

}

else {

returnNode = CreateUnlinkedNode<XMLText>( _textPool );

returnNode->_parseLineNum = _parseCurLineNum; // Report line of first non-whitespace character

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

_parseCurLineNum = startLine;

}

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

{

// Edge case: XMLDocuments don't have a Value. Return null.

if ( this->ToDocument() )

return 0;

return _value.GetStr();

}

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

}

XMLNode* XMLNode::DeepClone(XMLDocument* target) const

{

XMLNode* clone = this->ShallowClone(target);

if (!clone) return 0;

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

XMLNode* childClone = child->DeepClone(target);

TIXMLASSERT(childClone);

clone->InsertEndChild(childClone);

}

return clone;

}

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 == addThis ) {

// Current state: BeforeThis -> AddThis -> OneAfterAddThis

// Now AddThis must disappear from it's location and then

// reappear between BeforeThis and OneAfterAddThis.

// So just leave it where it is.

return addThis;

}

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->ToElementWithName( name );

if ( element ) {

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->ToElementWithName( name );

if ( element ) {

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->ToElementWithName( name );

if ( element ) {

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->ToElementWithName( name );

if ( element ) {

return element;

}

}

return 0;

}

char* XMLNode::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )

{

// 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