#include "tinyxml2.h"

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

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

# 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

#if defined(_WIN64)

#define TIXML_FSEEK _fseeki64

#define TIXML_FTELL _ftelli64

#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__CYGWIN__)

#define TIXML_FSEEK fseeko

#define TIXML_FTELL ftello

#elif defined(__ANDROID__) && __ANDROID_API__ > 24

#define TIXML_FSEEK fseeko64

#define TIXML_FTELL ftello64

#else

#define TIXML_FSEEK fseek

#define TIXML_FTELL ftell

#endif

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

static const char LF = LINE_FEED;

static const char CARRIAGE_RETURN = static_cast<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;

const 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( static_cast<unsigned char>(*p) ) ) {

return 0;

}

char* const start = p;

++p;

while ( *p && XMLUtil::IsNameChar( static_cast<unsigned char>(*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;

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

{

// Assume an entity, and pull it out.

*length = 0;

static const uint32_t MAX_CODE_POINT = 0x10FFFF;

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

uint32_t ucs = 0;

ptrdiff_t delta = 0;

uint32_t mult = 1;

static const char SEMICOLON = ';';

bool hex = false;

uint32_t radix = 10;

const char* q = 0;

char terminator = '#';

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

// Hexadecimal.

hex = true;

radix = 16;

terminator = 'x';

q = p + 3;

}

else {

// Decimal.

q = p + 2;

}

if (!(*q)) {

return 0;

}

q = strchr(q, SEMICOLON);

if (!q) {

return 0;

}

TIXMLASSERT(*q == SEMICOLON);

delta = q - p;

--q;

while (*q != terminator) {

uint32_t digit = 0;

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

digit = *q - '0';

}

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

digit = *q - 'a' + 10;

}

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

digit = *q - 'A' + 10;

}

else {

return 0;

}

TIXMLASSERT(digit < radix);

const unsigned int digitScaled = mult * digit;

ucs += digitScaled;

mult *= radix;

// Security check: could a value exist that is out of range?

// Easily; limit to the MAX_CODE_POINT, which also allows for a

// bunch of leading zeroes.

if (mult > MAX_CODE_POINT) {

mult = MAX_CODE_POINT;

}

--q;

}

// Out of range:

if (ucs > MAX_CODE_POINT) {

return 0;

}

// convert the UCS to UTF-8

ConvertUTF32ToUTF8(ucs, value, length);

if (length == 0) {

// If length is 0, there was an error. (Security? Bad input?)

// Fail safely.

return 0;

}

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 )

}

void XMLUtil::ToStr( uint64_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)

}

bool XMLUtil::ToUnsigned64(const char* str, uint64_t* value) {

}

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

{

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

// Preserve whitespace pedantically before closing tag, when it's immediately after opening tag

if (WhitespaceMode() == PEDANTIC_WHITESPACE && first && p != start && *(p + elementHeaderLen) == '/') {

returnNode = CreateUnlinkedNode<XMLText>(_textPool);

returnNode->_parseLineNum = startLine;

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

_parseCurLineNum = startLine;

}

else {

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

}

}

int XMLNode::ChildElementCount(const char *value) const {

}

int XMLNode::ChildElementCount() const {

}

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