[geos-commits] [SCM] GEOS branch master updated. 8d765e4aa4c1e61b66e28de98444a72f2d5e0320
git at osgeo.org
git at osgeo.org
Tue Nov 13 11:49:28 PST 2018
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GEOS".
The branch, master has been updated
via 8d765e4aa4c1e61b66e28de98444a72f2d5e0320 (commit)
from 4aedca1ddc3b363c6d319b67bd056dddcb461d69 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 8d765e4aa4c1e61b66e28de98444a72f2d5e0320
Author: Paul Ramsey <pramsey at cleverelephant.ca>
Date: Tue Nov 13 11:49:20 2018 -0800
Update to latest tinyxml2
diff --git a/tests/xmltester/tinyxml2/tinyxml2.cpp b/tests/xmltester/tinyxml2/tinyxml2.cpp
index 8297159..23a3a6c 100755
--- a/tests/xmltester/tinyxml2/tinyxml2.cpp
+++ b/tests/xmltester/tinyxml2/tinyxml2.cpp
@@ -24,12 +24,83 @@ distribution.
#include "tinyxml2.h"
#include <new> // yes, this one new style header, is in the Android SDK.
-# ifdef ANDROID_NDK
+#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(
+ char *buffer,
+ size_t sizeOfBuffer,
+ size_t count,
+ const char *format [,
+ argument] ...
+ );*/
+ static inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
+ {
+ va_list va;
+ va_start( va, format );
+ int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
+ va_end( va );
+ return result;
+ }
+
+ static inline int TIXML_VSNPRINTF( char* buffer, size_t size, const char* format, va_list va )
+ {
+ int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
+ return result;
+ }
+
+ #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 )
+ {
+ int len = 512;
+ for (;;) {
+ len = len*2;
+ char* str = new char[len]();
+ const int required = _vsnprintf(str, len, format, va);
+ delete[] str;
+ if ( required != -1 ) {
+ TIXMLASSERT( required >= 0 );
+ len = required;
+ break;
+ }
+ }
+ TIXMLASSERT( len >= 0 );
+ return len;
+ }
+ #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 )
+ {
+ int len = vsnprintf( 0, 0, format, va );
+ TIXMLASSERT( len >= 0 );
+ return len;
+ }
+ #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
@@ -70,6 +141,31 @@ StrPair::~StrPair()
}
+void StrPair::TransferTo( StrPair* other )
+{
+ if ( this == other ) {
+ return;
+ }
+ // This in effect implements the assignment operator by "moving"
+ // ownership (as in auto_ptr).
+
+ TIXMLASSERT( other != 0 );
+ TIXMLASSERT( other->_flags == 0 );
+ TIXMLASSERT( other->_start == 0 );
+ TIXMLASSERT( other->_end == 0 );
+
+ other->Reset();
+
+ other->_flags = _flags;
+ other->_start = _start;
+ other->_end = _end;
+
+ _flags = 0;
+ _start = 0;
+ _end = 0;
+}
+
+
void StrPair::Reset()
{
if ( _flags & NEEDS_DELETE ) {
@@ -83,8 +179,10 @@ void StrPair::Reset()
void StrPair::SetStr( const char* str, int flags )
{
+ TIXMLASSERT( str );
Reset();
size_t len = strlen( str );
+ TIXMLASSERT( _start == 0 );
_start = new char[ len+1 ];
memcpy( _start, str, len+1 );
_end = _start + len;
@@ -92,9 +190,11 @@ void StrPair::SetStr( const char* str, int flags )
}
-char* StrPair::ParseText( char* p, const char* endTag, int strFlags )
+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;
@@ -105,8 +205,11 @@ char* StrPair::ParseText( char* p, const char* endTag, int strFlags )
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;
}
@@ -114,21 +217,21 @@ char* StrPair::ParseText( char* p, const char* endTag, int strFlags )
char* StrPair::ParseName( char* p )
{
- char* start = p;
-
- if ( !start || !(*start) ) {
+ if ( !p || !(*p) ) {
+ return 0;
+ }
+ if ( !XMLUtil::IsNameStartChar( *p ) ) {
return 0;
}
- while( *p && ( p == start ? XMLUtil::IsNameStartChar( *p ) : XMLUtil::IsNameChar( *p ) )) {
+ char* const start = p;
+ ++p;
+ while ( *p && XMLUtil::IsNameChar( *p ) ) {
++p;
}
- if ( p > start ) {
- Set( start, p, 0 );
- return p;
- }
- return 0;
+ Set( start, p, 0 );
+ return p;
}
@@ -137,15 +240,15 @@ void StrPair::CollapseWhitespace()
// Adjusting _start would cause undefined behavior on delete[]
TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );
// Trim leading space.
- _start = XMLUtil::SkipWhiteSpace( _start );
+ _start = XMLUtil::SkipWhiteSpace( _start, 0 );
- if ( _start && *_start ) {
- char* p = _start; // the read pointer
+ if ( *_start ) {
+ const char* p = _start; // the read pointer
char* q = _start; // the write pointer
while( *p ) {
if ( XMLUtil::IsWhiteSpace( *p )) {
- p = XMLUtil::SkipWhiteSpace( p );
+ p = XMLUtil::SkipWhiteSpace( p, 0 );
if ( *p == 0 ) {
break; // don't write to q; this trims the trailing space.
}
@@ -163,12 +266,14 @@ 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
+ const char* p = _start; // the read pointer
char* q = _start; // the write pointer
while( p < _end ) {
@@ -182,7 +287,8 @@ const char* StrPair::GetStr()
else {
++p;
}
- *q++ = LF;
+ *q = LF;
+ ++q;
}
else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
if ( *(p+1) == CR ) {
@@ -191,7 +297,8 @@ const char* StrPair::GetStr()
else {
++p;
}
- *q++ = LF;
+ *q = LF;
+ ++q;
}
else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
// Entities handled by tinyXML2:
@@ -203,25 +310,35 @@ const char* StrPair::GetStr()
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;
+ 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 {
- int i=0;
- for(; i<NUM_ENTITIES; ++i ) {
- if ( strncmp( p+1, entities[i].pattern, entities[i].length ) == 0
- && *(p+entities[i].length+1) == ';' ) {
- // Found an entity convert;
- *q = entities[i].value;
+ 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 += entities[i].length + 2;
+ p += entity.length + 2;
+ entityFound = true;
break;
}
}
- if ( i == NUM_ENTITIES ) {
+ if ( !entityFound ) {
// fixme: treat as error?
++p;
++q;
@@ -238,11 +355,12 @@ const char* StrPair::GetStr()
}
// The loop below has plenty going on, and this
// is a less useful mode. Break it out.
- if ( _flags & COLLAPSE_WHITESPACE ) {
+ if ( _flags & NEEDS_WHITESPACE_COLLAPSING ) {
CollapseWhitespace();
}
_flags = (_flags & NEEDS_DELETE);
}
+ TIXMLASSERT( _start );
return _start;
}
@@ -251,8 +369,23 @@ const char* StrPair::GetStr()
// --------- XMLUtil ----------- //
+const char* XMLUtil::writeBoolTrue = "true";
+const char* XMLUtil::writeBoolFalse = "false";
+
+void XMLUtil::SetBoolSerialization(const char* writeTrue, const char* writeFalse)
+{
+ static const char* defTrue = "true";
+ static const char* defFalse = "false";
+
+ writeBoolTrue = (writeTrue) ? writeTrue : defTrue;
+ writeBoolFalse = (writeFalse) ? writeFalse : defFalse;
+}
+
+
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:
@@ -262,6 +395,7 @@ const char* XMLUtil::ReadBOM( const char* p, bool* bom )
*bom = true;
p += 3;
}
+ TIXMLASSERT( p );
return p;
}
@@ -285,31 +419,36 @@ void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length
*length = 4;
}
else {
- *length = 0; // This code won't covert this correctly anyway.
+ *length = 0; // This code won't convert this correctly anyway.
return;
}
output += *length;
- // Scary scary fall throughs.
+ // Scary scary fall throughs are annotated with carefully designed comments
+ // to suppress compiler warnings such as -Wimplicit-fallthrough in gcc
switch (*length) {
case 4:
--output;
*output = (char)((input | BYTE_MARK) & BYTE_MASK);
input >>= 6;
+ //fall through
case 3:
--output;
*output = (char)((input | BYTE_MARK) & BYTE_MASK);
input >>= 6;
+ //fall through
case 2:
--output;
*output = (char)((input | BYTE_MARK) & BYTE_MASK);
input >>= 6;
+ //fall through
case 1:
--output;
*output = (char)(input | FIRST_BYTE_MARK[*length]);
- default:
break;
+ default:
+ TIXMLASSERT( false );
}
}
@@ -321,65 +460,83 @@ const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )
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.
- if ( !*(p+3) ) {
+ const char* q = p+3;
+ if ( !(*q) ) {
return 0;
}
- const char* q = p+3;
- q = strchr( q, ';' );
+ q = strchr( q, SEMICOLON );
- if ( !q || !*q ) {
+ if ( !q ) {
return 0;
}
+ TIXMLASSERT( *q == SEMICOLON );
delta = q-p;
--q;
while ( *q != 'x' ) {
+ unsigned int digit = 0;
+
if ( *q >= '0' && *q <= '9' ) {
- ucs += mult * (*q - '0');
+ digit = *q - '0';
}
else if ( *q >= 'a' && *q <= 'f' ) {
- ucs += mult * (*q - 'a' + 10);
+ digit = *q - 'a' + 10;
}
else if ( *q >= 'A' && *q <= 'F' ) {
- ucs += mult * (*q - 'A' + 10 );
+ 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.
- if ( !*(p+2) ) {
+ const char* q = p+2;
+ if ( !(*q) ) {
return 0;
}
- const char* q = p+2;
- q = strchr( q, ';' );
+ q = strchr( q, SEMICOLON );
- if ( !q || !*q ) {
+ if ( !q ) {
return 0;
}
+ TIXMLASSERT( *q == SEMICOLON );
delta = q-p;
--q;
while ( *q != '#' ) {
if ( *q >= '0' && *q <= '9' ) {
- ucs += mult * (*q - '0');
+ 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;
}
@@ -406,7 +563,7 @@ void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )
void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
{
- TIXML_SNPRINTF( buffer, bufferSize, "%d", v ? 1 : 0 );
+ TIXML_SNPRINTF( buffer, bufferSize, "%s", v ? writeBoolTrue : writeBoolFalse);
}
/*
@@ -425,6 +582,13 @@ void XMLUtil::ToStr( double v, char* buffer, int bufferSize )
}
+void XMLUtil::ToStr(int64_t v, char* buffer, int bufferSize)
+{
+ // horrible syntax trick to make the compiler happy about %lld
+ TIXML_SNPRINTF(buffer, bufferSize, "%lld", (long long)v);
+}
+
+
bool XMLUtil::ToInt( const char* str, int* value )
{
if ( TIXML_SSCANF( str, "%d", value ) == 1 ) {
@@ -468,6 +632,7 @@ bool XMLUtil::ToFloat( const char* str, float* value )
return false;
}
+
bool XMLUtil::ToDouble( const char* str, double* value )
{
if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) {
@@ -477,71 +642,82 @@ bool XMLUtil::ToDouble( const char* str, double* value )
}
+bool XMLUtil::ToInt64(const char* str, int64_t* value)
+{
+ long long v = 0; // horrible syntax trick to make the compiler happy about %lld
+ if (TIXML_SSCANF(str, "%lld", &v) == 1) {
+ *value = (int64_t)v;
+ return true;
+ }
+ return false;
+}
+
+
char* XMLDocument::Identify( char* p, XMLNode** node )
{
- XMLNode* returnNode = 0;
- char* start = p;
- p = XMLUtil::SkipWhiteSpace( p );
- if( !p || !*p ) {
+ 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;
}
- // What is this thing?
- // These strings define the matching patters:
+ // These strings define the matching patterns:
static const char* xmlHeader = { "<?" };
static const char* commentHeader = { "<!--" };
- static const char* dtdHeader = { "<!" };
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 dtdHeaderLen = 2;
static const int cdataHeaderLen = 9;
+ static const int dtdHeaderLen = 2;
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;
+ returnNode = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
+ returnNode->_parseLineNum = _parseCurLineNum;
p += xmlHeaderLen;
}
else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
- returnNode = new (_commentPool.Alloc()) XMLComment( this );
- returnNode->_memPool = &_commentPool;
+ returnNode = CreateUnlinkedNode<XMLComment>( _commentPool );
+ returnNode->_parseLineNum = _parseCurLineNum;
p += commentHeaderLen;
}
else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
- XMLText* text = new (_textPool.Alloc()) XMLText( this );
+ XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
returnNode = text;
- returnNode->_memPool = &_textPool;
+ returnNode->_parseLineNum = _parseCurLineNum;
p += cdataHeaderLen;
text->SetCData( true );
}
else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
- returnNode = new (_commentPool.Alloc()) XMLUnknown( this );
- returnNode->_memPool = &_commentPool;
+ returnNode = CreateUnlinkedNode<XMLUnknown>( _commentPool );
+ returnNode->_parseLineNum = _parseCurLineNum;
p += dtdHeaderLen;
}
else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
- returnNode = new (_elementPool.Alloc()) XMLElement( this );
- returnNode->_memPool = &_elementPool;
+ returnNode = CreateUnlinkedNode<XMLElement>( _elementPool );
+ returnNode->_parseLineNum = _parseCurLineNum;
p += elementHeaderLen;
}
else {
- returnNode = new (_textPool.Alloc()) XMLText( this );
- returnNode->_memPool = &_textPool;
+ 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;
}
@@ -549,6 +725,7 @@ char* XMLDocument::Identify( char* p, XMLNode** node )
bool XMLDocument::Accept( XMLVisitor* visitor ) const
{
+ TIXMLASSERT( visitor );
if ( visitor->VisitEnter( *this ) ) {
for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
if ( !node->Accept( visitor ) ) {
@@ -565,8 +742,11 @@ bool XMLDocument::Accept( XMLVisitor* visitor ) const
XMLNode::XMLNode( XMLDocument* doc ) :
_document( doc ),
_parent( 0 ),
+ _value(),
+ _parseLineNum( 0 ),
_firstChild( 0 ), _lastChild( 0 ),
_prev( 0 ), _next( 0 ),
+ _userData( 0 ),
_memPool( 0 )
{
}
@@ -580,8 +760,11 @@ XMLNode::~XMLNode()
}
}
-const char* XMLNode::Value() const
+const char* XMLNode::Value() const
{
+ // Edge case: XMLDocuments don't have a Value. Return null.
+ if ( this->ToDocument() )
+ return 0;
return _value.GetStr();
}
@@ -595,14 +778,24 @@ 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()
{
while( _firstChild ) {
- XMLNode* node = _firstChild;
- Unlink( node );
-
- DeleteNode( node );
+ TIXMLASSERT( _lastChild );
+ DeleteChild( _firstChild );
}
_firstChild = _lastChild = 0;
}
@@ -610,6 +803,9 @@ void XMLNode::DeleteChildren()
void XMLNode::Unlink( XMLNode* child )
{
+ TIXMLASSERT( child );
+ TIXMLASSERT( child->_document == _document );
+ TIXMLASSERT( child->_parent == this );
if ( child == _firstChild ) {
_firstChild = _firstChild->_next;
}
@@ -623,26 +819,33 @@ void XMLNode::Unlink( XMLNode* child )
if ( child->_next ) {
child->_next->_prev = child->_prev;
}
+ child->_next = 0;
+ child->_prev = 0;
child->_parent = 0;
}
void XMLNode::DeleteChild( XMLNode* node )
{
+ TIXMLASSERT( node );
+ TIXMLASSERT( node->_document == _document );
TIXMLASSERT( node->_parent == this );
+ Unlink( node );
+ TIXMLASSERT(node->_prev == 0);
+ TIXMLASSERT(node->_next == 0);
+ TIXMLASSERT(node->_parent == 0);
DeleteNode( node );
}
XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
{
- if (addThis->_document != _document)
- return 0;
-
- if (addThis->_parent)
- addThis->_parent->Unlink( addThis );
- else
- addThis->_memPool->SetTracked();
+ TIXMLASSERT( addThis );
+ if ( addThis->_document != _document ) {
+ TIXMLASSERT( false );
+ return 0;
+ }
+ InsertChildPreamble( addThis );
if ( _lastChild ) {
TIXMLASSERT( _firstChild );
@@ -667,13 +870,12 @@ XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
{
- if (addThis->_document != _document)
- return 0;
-
- if (addThis->_parent)
- addThis->_parent->Unlink( addThis );
- else
- addThis->_memPool->SetTracked();
+ TIXMLASSERT( addThis );
+ if ( addThis->_document != _document ) {
+ TIXMLASSERT( false );
+ return 0;
+ }
+ InsertChildPreamble( addThis );
if ( _firstChild ) {
TIXMLASSERT( _lastChild );
@@ -693,29 +895,37 @@ XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
addThis->_next = 0;
}
addThis->_parent = this;
- return addThis;
+ return addThis;
}
XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
{
- if (addThis->_document != _document)
- return 0;
+ TIXMLASSERT( addThis );
+ if ( addThis->_document != _document ) {
+ TIXMLASSERT( false );
+ return 0;
+ }
- TIXMLASSERT( afterThis->_parent == this );
+ 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 );
}
- if (addThis->_parent)
- addThis->_parent->Unlink( addThis );
- else
- addThis->_memPool->SetTracked();
+ InsertChildPreamble( addThis );
addThis->_prev = afterThis;
addThis->_next = afterThis->_next;
afterThis->_next->_prev = addThis;
@@ -727,40 +937,35 @@ XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
-const XMLElement* XMLNode::FirstChildElement( const char* value ) const
+const XMLElement* XMLNode::FirstChildElement( const char* name ) const
{
- for( XMLNode* node=_firstChild; node; node=node->_next ) {
- XMLElement* element = node->ToElement();
+ for( const XMLNode* node = _firstChild; node; node = node->_next ) {
+ const XMLElement* element = node->ToElementWithName( name );
if ( element ) {
- if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) {
- return element;
- }
+ return element;
}
}
return 0;
}
-const XMLElement* XMLNode::LastChildElement( const char* value ) const
+const XMLElement* XMLNode::LastChildElement( const char* name ) const
{
- for( XMLNode* node=_lastChild; node; node=node->_prev ) {
- XMLElement* element = node->ToElement();
+ for( const XMLNode* node = _lastChild; node; node = node->_prev ) {
+ const XMLElement* element = node->ToElementWithName( name );
if ( element ) {
- if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) {
- return element;
- }
+ return element;
}
}
return 0;
}
-const XMLElement* XMLNode::NextSiblingElement( const char* value ) const
+const XMLElement* XMLNode::NextSiblingElement( const char* name ) const
{
- for( XMLNode* node=this->_next; node; node = node->_next ) {
- const XMLElement* element = node->ToElement();
- if ( element
- && (!value || XMLUtil::StringEqual( value, node->Value() ))) {
+ for( const XMLNode* node = _next; node; node = node->_next ) {
+ const XMLElement* element = node->ToElementWithName( name );
+ if ( element ) {
return element;
}
}
@@ -768,12 +973,11 @@ const XMLElement* XMLNode::NextSiblingElement( const char* value ) const
}
-const XMLElement* XMLNode::PreviousSiblingElement( const char* value ) const
+const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const
{
- for( XMLNode* node=_prev; node; node = node->_prev ) {
- const XMLElement* element = node->ToElement();
- if ( element
- && (!value || XMLUtil::StringEqual( value, node->Value() ))) {
+ for( const XMLNode* node = _prev; node; node = node->_prev ) {
+ const XMLElement* element = node->ToElementWithName( name );
+ if ( element ) {
return element;
}
}
@@ -781,7 +985,7 @@ const XMLElement* XMLNode::PreviousSiblingElement( const char* value ) const
}
-char* XMLNode::ParseDeep( char* p, StrPair* parentEnd )
+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:
@@ -800,99 +1004,168 @@ char* XMLNode::ParseDeep( char* p, StrPair* parentEnd )
// '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 ) {
+ XMLDocument::DepthTracker tracker(_document);
+ if (_document->Error())
+ return 0;
+
+ while( p && *p ) {
XMLNode* node = 0;
p = _document->Identify( p, &node );
- if ( p == 0 || node == 0 ) {
+ TIXMLASSERT( p );
+ if ( node == 0 ) {
break;
}
+ int initialLineNum = node->_parseLineNum;
+
StrPair endTag;
- p = node->ParseDeep( p, &endTag );
+ p = node->ParseDeep( p, &endTag, curLineNumPtr );
if ( !p ) {
DeleteNode( node );
- node = 0;
if ( !_document->Error() ) {
- _document->SetError( XML_ERROR_PARSING, 0, 0 );
+ _document->SetError( XML_ERROR_PARSING, initialLineNum, 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 = static_cast<XMLElement*>(node)->_value;
+ XMLDeclaration* decl = node->ToDeclaration();
+ if ( decl ) {
+ // Declarations are only allowed at document level
+ //
+ // Multiple declarations are allowed but all declarations
+ // must occur before anything else.
+ //
+ // Optimized due to a security test case. If the first node is
+ // a declaration, and the last node is a declaration, then only
+ // declarations have so far been addded.
+ bool wellLocated = false;
+
+ if (ToDocument()) {
+ if (FirstChild()) {
+ wellLocated =
+ FirstChild() &&
+ FirstChild()->ToDeclaration() &&
+ LastChild() &&
+ LastChild()->ToDeclaration();
+ }
+ else {
+ wellLocated = true;
+ }
+ }
+ if ( !wellLocated ) {
+ _document->SetError( XML_ERROR_PARSING_DECLARATION, initialLineNum, "XMLDeclaration value=%s", decl->Value());
+ DeleteNode( node );
+ break;
}
- 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.
+ XMLElement* ele = node->ToElement();
if ( ele ) {
- if ( endTag.Empty() && ele->ClosingType() == XMLElement::OPEN ) {
- _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );
- p = 0;
+ // We read the end tag. Return it to the parent.
+ if ( ele->ClosingType() == XMLElement::CLOSING ) {
+ if ( parentEndTag ) {
+ ele->_value.TransferTo( parentEndTag );
+ }
+ node->_memPool->SetTracked(); // created and then immediately deleted.
+ DeleteNode( node );
+ return p;
}
- else if ( !endTag.Empty() && ele->ClosingType() != XMLElement::OPEN ) {
- _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );
- p = 0;
+
+ // 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 ( !endTag.Empty() ) {
- if ( !XMLUtil::StringEqual( endTag.GetStr(), node->Value() )) {
- _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );
- p = 0;
+ else {
+ if ( ele->ClosingType() != XMLElement::OPEN ) {
+ mismatch = true;
+ }
+ else if ( !XMLUtil::StringEqual( endTag.GetStr(), ele->Name() ) ) {
+ mismatch = true;
}
}
+ if ( mismatch ) {
+ _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, initialLineNum, "XMLElement name=%s", ele->Name());
+ DeleteNode( node );
+ break;
+ }
}
- if ( p == 0 ) {
- DeleteNode( node );
- node = 0;
- }
- if ( node ) {
- this->InsertEndChild( node );
- }
+ InsertEndChild( node );
}
return 0;
}
-void XMLNode::DeleteNode( XMLNode* node )
+/*static*/ void XMLNode::DeleteNode( XMLNode* node )
{
if ( node == 0 ) {
return;
}
+ TIXMLASSERT(node->_document);
+ if (!node->ToDocument()) {
+ node->_document->MarkInUse(node);
+ }
+
MemPool* pool = node->_memPool;
node->~XMLNode();
pool->Free( node );
}
+void XMLNode::InsertChildPreamble( XMLNode* insertThis ) const
+{
+ TIXMLASSERT( insertThis );
+ TIXMLASSERT( insertThis->_document == _document );
+
+ if (insertThis->_parent) {
+ insertThis->_parent->Unlink( insertThis );
+ }
+ else {
+ insertThis->_document->MarkInUse(insertThis);
+ insertThis->_memPool->SetTracked();
+ }
+}
+
+const XMLElement* XMLNode::ToElementWithName( const char* name ) const
+{
+ const XMLElement* element = this->ToElement();
+ if ( element == 0 ) {
+ return 0;
+ }
+ if ( name == 0 ) {
+ return element;
+ }
+ if ( XMLUtil::StringEqual( element->Name(), name ) ) {
+ return element;
+ }
+ return 0;
+}
+
// --------- XMLText ---------- //
-char* XMLText::ParseDeep( char* p, StrPair* )
+char* XMLText::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
{
- const char* start = p;
if ( this->CData() ) {
- p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
+ p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
if ( !p ) {
- _document->SetError( XML_ERROR_PARSING_CDATA, start, 0 );
+ _document->SetError( XML_ERROR_PARSING_CDATA, _parseLineNum, 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;
+ flags |= StrPair::NEEDS_WHITESPACE_COLLAPSING;
}
- p = _value.ParseText( p, "<", flags );
- if ( !p ) {
- _document->SetError( XML_ERROR_PARSING_TEXT, start, 0 );
- }
+ p = _value.ParseText( p, "<", flags, curLineNumPtr );
if ( p && *p ) {
return p-1;
}
+ if ( !p ) {
+ _document->SetError( XML_ERROR_PARSING_TEXT, _parseLineNum, 0 );
+ }
}
return 0;
}
@@ -911,12 +1184,15 @@ XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
bool XMLText::ShallowEqual( const XMLNode* compare ) const
{
- return ( compare->ToText() && XMLUtil::StringEqual( compare->ToText()->Value(), Value() ));
+ TIXMLASSERT( compare );
+ const XMLText* text = compare->ToText();
+ return ( text && XMLUtil::StringEqual( text->Value(), Value() ) );
}
bool XMLText::Accept( XMLVisitor* visitor ) const
{
+ TIXMLASSERT( visitor );
return visitor->Visit( *this );
}
@@ -933,13 +1209,12 @@ XMLComment::~XMLComment()
}
-char* XMLComment::ParseDeep( char* p, StrPair* )
+char* XMLComment::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
{
// Comment parses as text.
- const char* start = p;
- p = _value.ParseText( p, "-->", StrPair::COMMENT );
+ p = _value.ParseText( p, "-->", StrPair::COMMENT, curLineNumPtr );
if ( p == 0 ) {
- _document->SetError( XML_ERROR_PARSING_COMMENT, start, 0 );
+ _document->SetError( XML_ERROR_PARSING_COMMENT, _parseLineNum, 0 );
}
return p;
}
@@ -957,6 +1232,7 @@ XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const
bool XMLComment::ShallowEqual( const XMLNode* compare ) const
{
+ TIXMLASSERT( compare );
const XMLComment* comment = compare->ToComment();
return ( comment && XMLUtil::StringEqual( comment->Value(), Value() ));
}
@@ -964,6 +1240,7 @@ bool XMLComment::ShallowEqual( const XMLNode* compare ) const
bool XMLComment::Accept( XMLVisitor* visitor ) const
{
+ TIXMLASSERT( visitor );
return visitor->Visit( *this );
}
@@ -981,13 +1258,12 @@ XMLDeclaration::~XMLDeclaration()
}
-char* XMLDeclaration::ParseDeep( char* p, StrPair* )
+char* XMLDeclaration::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
{
// Declaration parses as text.
- const char* start = p;
- p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
+ p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
if ( p == 0 ) {
- _document->SetError( XML_ERROR_PARSING_DECLARATION, start, 0 );
+ _document->SetError( XML_ERROR_PARSING_DECLARATION, _parseLineNum, 0 );
}
return p;
}
@@ -1005,6 +1281,7 @@ XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const
bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const
{
+ TIXMLASSERT( compare );
const XMLDeclaration* declaration = compare->ToDeclaration();
return ( declaration && XMLUtil::StringEqual( declaration->Value(), Value() ));
}
@@ -1013,6 +1290,7 @@ bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const
bool XMLDeclaration::Accept( XMLVisitor* visitor ) const
{
+ TIXMLASSERT( visitor );
return visitor->Visit( *this );
}
@@ -1028,14 +1306,12 @@ XMLUnknown::~XMLUnknown()
}
-char* XMLUnknown::ParseDeep( char* p, StrPair* )
+char* XMLUnknown::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
{
// Unknown parses as text.
- const char* start = p;
-
- p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION );
+ p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
if ( !p ) {
- _document->SetError( XML_ERROR_PARSING_UNKNOWN, start, 0 );
+ _document->SetError( XML_ERROR_PARSING_UNKNOWN, _parseLineNum, 0 );
}
return p;
}
@@ -1053,6 +1329,7 @@ XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const
bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const
{
+ TIXMLASSERT( compare );
const XMLUnknown* unknown = compare->ToUnknown();
return ( unknown && XMLUtil::StringEqual( unknown->Value(), Value() ));
}
@@ -1060,22 +1337,23 @@ bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const
bool XMLUnknown::Accept( XMLVisitor* visitor ) const
{
+ TIXMLASSERT( visitor );
return visitor->Visit( *this );
}
// --------- XMLAttribute ---------- //
-const char* XMLAttribute::Name() const
+const char* XMLAttribute::Name() const
{
return _name.GetStr();
}
-const char* XMLAttribute::Value() const
+const char* XMLAttribute::Value() const
{
return _value.GetStr();
}
-char* XMLAttribute::ParseDeep( char* p, bool processEntities )
+char* XMLAttribute::ParseDeep( char* p, bool processEntities, int* curLineNumPtr )
{
// Parse using the name rules: bug fix, was using ParseText before
p = _name.ParseName( p );
@@ -1084,13 +1362,13 @@ char* XMLAttribute::ParseDeep( char* p, bool processEntities )
}
// Skip white space before =
- p = XMLUtil::SkipWhiteSpace( p );
- if ( !p || *p != '=' ) {
+ p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
+ if ( *p != '=' ) {
return 0;
}
++p; // move up to opening quote
- p = XMLUtil::SkipWhiteSpace( p );
+ p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
if ( *p != '\"' && *p != '\'' ) {
return 0;
}
@@ -1098,7 +1376,7 @@ char* XMLAttribute::ParseDeep( char* p, bool processEntities )
char endTag[2] = { *p, 0 };
++p; // move past opening quote
- p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES );
+ p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES, curLineNumPtr );
return p;
}
@@ -1112,7 +1390,7 @@ void XMLAttribute::SetName( const char* n )
XMLError XMLAttribute::QueryIntValue( int* value ) const
{
if ( XMLUtil::ToInt( Value(), value )) {
- return XML_NO_ERROR;
+ return XML_SUCCESS;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
@@ -1121,16 +1399,25 @@ XMLError XMLAttribute::QueryIntValue( int* value ) const
XMLError XMLAttribute::QueryUnsignedValue( unsigned int* value ) const
{
if ( XMLUtil::ToUnsigned( Value(), value )) {
- return XML_NO_ERROR;
+ return XML_SUCCESS;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
+XMLError XMLAttribute::QueryInt64Value(int64_t* value) const
+{
+ if (XMLUtil::ToInt64(Value(), value)) {
+ return XML_SUCCESS;
+ }
+ return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
XMLError XMLAttribute::QueryBoolValue( bool* value ) const
{
if ( XMLUtil::ToBool( Value(), value )) {
- return XML_NO_ERROR;
+ return XML_SUCCESS;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
@@ -1139,7 +1426,7 @@ XMLError XMLAttribute::QueryBoolValue( bool* value ) const
XMLError XMLAttribute::QueryFloatValue( float* value ) const
{
if ( XMLUtil::ToFloat( Value(), value )) {
- return XML_NO_ERROR;
+ return XML_SUCCESS;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
@@ -1148,7 +1435,7 @@ XMLError XMLAttribute::QueryFloatValue( float* value ) const
XMLError XMLAttribute::QueryDoubleValue( double* value ) const
{
if ( XMLUtil::ToDouble( Value(), value )) {
- return XML_NO_ERROR;
+ return XML_SUCCESS;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
@@ -1176,6 +1463,15 @@ void XMLAttribute::SetAttribute( unsigned v )
}
+void XMLAttribute::SetAttribute(int64_t v)
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ _value.SetStr(buf);
+}
+
+
+
void XMLAttribute::SetAttribute( bool v )
{
char buf[BUF_SIZE];
@@ -1200,7 +1496,7 @@ void XMLAttribute::SetAttribute( float v )
// --------- XMLElement ---------- //
XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),
- _closingType( 0 ),
+ _closingType( OPEN ),
_rootAttribute( 0 )
{
}
@@ -1216,17 +1512,6 @@ XMLElement::~XMLElement()
}
-XMLAttribute* XMLElement::FindAttribute( const char* name )
-{
- for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
- if ( XMLUtil::StringEqual( a->Name(), name ) ) {
- return a;
- }
- }
- return 0;
-}
-
-
const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
{
for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
@@ -1250,11 +1535,52 @@ const char* XMLElement::Attribute( const char* name, const char* value ) const
return 0;
}
+int XMLElement::IntAttribute(const char* name, int defaultValue) const
+{
+ int i = defaultValue;
+ QueryIntAttribute(name, &i);
+ return i;
+}
+
+unsigned XMLElement::UnsignedAttribute(const char* name, unsigned defaultValue) const
+{
+ unsigned i = defaultValue;
+ QueryUnsignedAttribute(name, &i);
+ return i;
+}
+
+int64_t XMLElement::Int64Attribute(const char* name, int64_t defaultValue) const
+{
+ int64_t i = defaultValue;
+ QueryInt64Attribute(name, &i);
+ return i;
+}
+
+bool XMLElement::BoolAttribute(const char* name, bool defaultValue) const
+{
+ bool b = defaultValue;
+ QueryBoolAttribute(name, &b);
+ return b;
+}
+
+double XMLElement::DoubleAttribute(const char* name, double defaultValue) const
+{
+ double d = defaultValue;
+ QueryDoubleAttribute(name, &d);
+ return d;
+}
+
+float XMLElement::FloatAttribute(const char* name, float defaultValue) const
+{
+ float f = defaultValue;
+ QueryFloatAttribute(name, &f);
+ return f;
+}
const char* XMLElement::GetText() const
{
if ( FirstChild() && FirstChild()->ToText() ) {
- return FirstChild()->ToText()->Value();
+ return FirstChild()->Value();
}
return 0;
}
@@ -1271,7 +1597,7 @@ void XMLElement::SetText( const char* inText )
}
-void XMLElement::SetText( int v )
+void XMLElement::SetText( int v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
@@ -1279,7 +1605,7 @@ void XMLElement::SetText( int v )
}
-void XMLElement::SetText( unsigned v )
+void XMLElement::SetText( unsigned v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
@@ -1287,7 +1613,15 @@ void XMLElement::SetText( unsigned v )
}
-void XMLElement::SetText( bool v )
+void XMLElement::SetText(int64_t v)
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ SetText(buf);
+}
+
+
+void XMLElement::SetText( bool v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
@@ -1295,7 +1629,7 @@ void XMLElement::SetText( bool v )
}
-void XMLElement::SetText( float v )
+void XMLElement::SetText( float v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
@@ -1303,7 +1637,7 @@ void XMLElement::SetText( float v )
}
-void XMLElement::SetText( double v )
+void XMLElement::SetText( double v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
@@ -1314,7 +1648,7 @@ void XMLElement::SetText( double v )
XMLError XMLElement::QueryIntText( int* ival ) const
{
if ( FirstChild() && FirstChild()->ToText() ) {
- const char* t = FirstChild()->ToText()->Value();
+ const char* t = FirstChild()->Value();
if ( XMLUtil::ToInt( t, ival ) ) {
return XML_SUCCESS;
}
@@ -1327,7 +1661,7 @@ XMLError XMLElement::QueryIntText( int* ival ) const
XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
{
if ( FirstChild() && FirstChild()->ToText() ) {
- const char* t = FirstChild()->ToText()->Value();
+ const char* t = FirstChild()->Value();
if ( XMLUtil::ToUnsigned( t, uval ) ) {
return XML_SUCCESS;
}
@@ -1337,10 +1671,23 @@ XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
}
+XMLError XMLElement::QueryInt64Text(int64_t* ival) const
+{
+ if (FirstChild() && FirstChild()->ToText()) {
+ const char* t = FirstChild()->Value();
+ if (XMLUtil::ToInt64(t, ival)) {
+ return XML_SUCCESS;
+ }
+ return XML_CAN_NOT_CONVERT_TEXT;
+ }
+ return XML_NO_TEXT_NODE;
+}
+
+
XMLError XMLElement::QueryBoolText( bool* bval ) const
{
if ( FirstChild() && FirstChild()->ToText() ) {
- const char* t = FirstChild()->ToText()->Value();
+ const char* t = FirstChild()->Value();
if ( XMLUtil::ToBool( t, bval ) ) {
return XML_SUCCESS;
}
@@ -1353,7 +1700,7 @@ XMLError XMLElement::QueryBoolText( bool* bval ) const
XMLError XMLElement::QueryDoubleText( double* dval ) const
{
if ( FirstChild() && FirstChild()->ToText() ) {
- const char* t = FirstChild()->ToText()->Value();
+ const char* t = FirstChild()->Value();
if ( XMLUtil::ToDouble( t, dval ) ) {
return XML_SUCCESS;
}
@@ -1366,7 +1713,7 @@ XMLError XMLElement::QueryDoubleText( double* dval ) const
XMLError XMLElement::QueryFloatText( float* fval ) const
{
if ( FirstChild() && FirstChild()->ToText() ) {
- const char* t = FirstChild()->ToText()->Value();
+ const char* t = FirstChild()->Value();
if ( XMLUtil::ToFloat( t, fval ) ) {
return XML_SUCCESS;
}
@@ -1375,6 +1722,47 @@ XMLError XMLElement::QueryFloatText( float* fval ) const
return XML_NO_TEXT_NODE;
}
+int XMLElement::IntText(int defaultValue) const
+{
+ int i = defaultValue;
+ QueryIntText(&i);
+ return i;
+}
+
+unsigned XMLElement::UnsignedText(unsigned defaultValue) const
+{
+ unsigned i = defaultValue;
+ QueryUnsignedText(&i);
+ return i;
+}
+
+int64_t XMLElement::Int64Text(int64_t defaultValue) const
+{
+ int64_t i = defaultValue;
+ QueryInt64Text(&i);
+ return i;
+}
+
+bool XMLElement::BoolText(bool defaultValue) const
+{
+ bool b = defaultValue;
+ QueryBoolText(&b);
+ return b;
+}
+
+double XMLElement::DoubleText(double defaultValue) const
+{
+ double d = defaultValue;
+ QueryDoubleText(&d);
+ return d;
+}
+
+float XMLElement::FloatText(float defaultValue) const
+{
+ float f = defaultValue;
+ QueryFloatText(&f);
+ return f;
+}
XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
@@ -1389,16 +1777,17 @@ XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
}
}
if ( !attrib ) {
- attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
- attrib->_memPool = &_document->_attributePool;
+ attrib = CreateAttribute();
+ TIXMLASSERT( attrib );
if ( last ) {
+ TIXMLASSERT( last->_next == 0 );
last->_next = attrib;
}
else {
+ TIXMLASSERT( _rootAttribute == 0 );
_rootAttribute = attrib;
}
attrib->SetName( name );
- attrib->_memPool->SetTracked(); // always created and linked.
}
return attrib;
}
@@ -1423,29 +1812,30 @@ void XMLElement::DeleteAttribute( const char* name )
}
-char* XMLElement::ParseAttributes( char* p )
+char* XMLElement::ParseAttributes( char* p, int* curLineNumPtr )
{
- const char* start = p;
XMLAttribute* prevAttribute = 0;
// Read the attributes.
while( p ) {
- p = XMLUtil::SkipWhiteSpace( p );
- if ( !p || !(*p) ) {
- _document->SetError( XML_ERROR_PARSING_ELEMENT, start, Name() );
+ p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
+ if ( !(*p) ) {
+ _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, "XMLElement name=%s", Name() );
return 0;
}
// attribute.
if (XMLUtil::IsNameStartChar( *p ) ) {
- XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
- attrib->_memPool = &_document->_attributePool;
- attrib->_memPool->SetTracked();
+ XMLAttribute* attrib = CreateAttribute();
+ TIXMLASSERT( attrib );
+ attrib->_parseLineNum = _document->_parseCurLineNum;
- p = attrib->ParseDeep( p, _document->ProcessEntities() );
+ int attrLineNum = attrib->_parseLineNum;
+
+ p = attrib->ParseDeep( p, _document->ProcessEntities(), curLineNumPtr );
if ( !p || Attribute( attrib->Name() ) ) {
DeleteAttribute( attrib );
- _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, start, p );
+ _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, attrLineNum, "XMLElement name=%s", Name() );
return 0;
}
// There is a minor bug here: if the attribute in the source xml
@@ -1454,25 +1844,27 @@ char* XMLElement::ParseAttributes( char* p )
// avoids re-scanning the attribute list. Preferring performance for
// now, may reconsider in the future.
if ( prevAttribute ) {
+ TIXMLASSERT( prevAttribute->_next == 0 );
prevAttribute->_next = attrib;
}
else {
+ TIXMLASSERT( _rootAttribute == 0 );
_rootAttribute = attrib;
}
prevAttribute = attrib;
}
// end of the tag
- else if ( *p == '/' && *(p+1) == '>' ) {
- _closingType = CLOSED;
- return p+2; // done; sealed element.
- }
- // end of the tag
else if ( *p == '>' ) {
++p;
break;
}
+ // end of the tag
+ else if ( *p == '/' && *(p+1) == '>' ) {
+ _closingType = CLOSED;
+ return p+2; // done; sealed element.
+ }
else {
- _document->SetError( XML_ERROR_PARSING_ELEMENT, start, p );
+ _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, 0 );
return 0;
}
}
@@ -1489,17 +1881,24 @@ void XMLElement::DeleteAttribute( XMLAttribute* attribute )
pool->Free( attribute );
}
+XMLAttribute* XMLElement::CreateAttribute()
+{
+ TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );
+ XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
+ TIXMLASSERT( attrib );
+ attrib->_memPool = &_document->_attributePool;
+ attrib->_memPool->SetTracked();
+ return attrib;
+}
+
//
// <ele></ele>
// <ele>foo<b>bar</b></ele>
//
-char* XMLElement::ParseDeep( char* p, StrPair* strPair )
+char* XMLElement::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
{
// Read the element name.
- p = XMLUtil::SkipWhiteSpace( p );
- if ( !p ) {
- return 0;
- }
+ p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
// The closing element is the </element> form. It is
// parsed just like a regular element then deleted from
@@ -1514,12 +1913,12 @@ char* XMLElement::ParseDeep( char* p, StrPair* strPair )
return 0;
}
- p = ParseAttributes( p );
- if ( !p || !*p || _closingType ) {
+ p = ParseAttributes( p, curLineNumPtr );
+ if ( !p || !*p || _closingType != OPEN ) {
return p;
}
- p = XMLNode::ParseDeep( p, strPair );
+ p = XMLNode::ParseDeep( p, parentEndTag, curLineNumPtr );
return p;
}
@@ -1540,8 +1939,9 @@ XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const
bool XMLElement::ShallowEqual( const XMLNode* compare ) const
{
+ TIXMLASSERT( compare );
const XMLElement* other = compare->ToElement();
- if ( other && XMLUtil::StringEqual( other->Value(), Value() )) {
+ if ( other && XMLUtil::StringEqual( other->Name(), Name() )) {
const XMLAttribute* a=FirstAttribute();
const XMLAttribute* b=other->FirstAttribute();
@@ -1565,6 +1965,7 @@ bool XMLElement::ShallowEqual( const XMLNode* compare ) const
bool XMLElement::Accept( XMLVisitor* visitor ) const
{
+ TIXMLASSERT( visitor );
if ( visitor->VisitEnter( *this, _rootAttribute ) ) {
for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
if ( !node->Accept( visitor ) ) {
@@ -1586,10 +1987,8 @@ const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {
"XML_ERROR_FILE_NOT_FOUND",
"XML_ERROR_FILE_COULD_NOT_BE_OPENED",
"XML_ERROR_FILE_READ_ERROR",
- "XML_ERROR_ELEMENT_MISMATCH",
"XML_ERROR_PARSING_ELEMENT",
"XML_ERROR_PARSING_ATTRIBUTE",
- "XML_ERROR_IDENTIFYING_TAG",
"XML_ERROR_PARSING_TEXT",
"XML_ERROR_PARSING_CDATA",
"XML_ERROR_PARSING_COMMENT",
@@ -1599,28 +1998,67 @@ const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {
"XML_ERROR_MISMATCHED_ELEMENT",
"XML_ERROR_PARSING",
"XML_CAN_NOT_CONVERT_TEXT",
- "XML_NO_TEXT_NODE"
+ "XML_NO_TEXT_NODE",
+ "XML_ELEMENT_DEPTH_EXCEEDED"
};
-XMLDocument::XMLDocument( bool processEntities, Whitespace whitespace ) :
+XMLDocument::XMLDocument( bool processEntities, Whitespace whitespaceMode ) :
XMLNode( 0 ),
_writeBOM( false ),
_processEntities( processEntities ),
- _errorID( XML_NO_ERROR ),
- _whitespace( whitespace ),
- _errorStr1( 0 ),
- _errorStr2( 0 ),
- _charBuffer( 0 )
+ _errorID(XML_SUCCESS),
+ _whitespaceMode( whitespaceMode ),
+ _errorStr(),
+ _errorLineNum( 0 ),
+ _charBuffer( 0 ),
+ _parseCurLineNum( 0 ),
+ _parsingDepth(0),
+ _unlinked(),
+ _elementPool(),
+ _attributePool(),
+ _textPool(),
+ _commentPool()
{
- _document = this; // avoid warning about 'this' in initializer list
+ // avoid VC++ C4355 warning about 'this' in initializer list (C4355 is off by default in VS2012+)
+ _document = this;
}
XMLDocument::~XMLDocument()
{
+ Clear();
+}
+
+
+void XMLDocument::MarkInUse(XMLNode* node)
+{
+ TIXMLASSERT(node);
+ TIXMLASSERT(node->_parent == 0);
+
+ for (int i = 0; i < _unlinked.Size(); ++i) {
+ if (node == _unlinked[i]) {
+ _unlinked.SwapRemove(i);
+ break;
+ }
+ }
+}
+
+void XMLDocument::Clear()
+{
DeleteChildren();
+ while( _unlinked.Size()) {
+ DeleteNode(_unlinked[0]); // Will remove from _unlinked as part of delete.
+ }
+
+#ifdef TINYXML2_DEBUG
+ const bool hadError = Error();
+#endif
+ ClearError();
+
delete [] _charBuffer;
+ _charBuffer = 0;
+ _parsingDepth = 0;
#if 0
_textPool.Trace( "text" );
@@ -1629,34 +2067,33 @@ XMLDocument::~XMLDocument()
_attributePool.Trace( "attribute" );
#endif
-#ifdef DEBUG
- if ( Error() == false ) {
- TIXMLASSERT( _elementPool.CurrentAllocs() == _elementPool.Untracked() );
- TIXMLASSERT( _attributePool.CurrentAllocs() == _attributePool.Untracked() );
- TIXMLASSERT( _textPool.CurrentAllocs() == _textPool.Untracked() );
- TIXMLASSERT( _commentPool.CurrentAllocs() == _commentPool.Untracked() );
- }
+#ifdef TINYXML2_DEBUG
+ if ( !hadError ) {
+ TIXMLASSERT( _elementPool.CurrentAllocs() == _elementPool.Untracked() );
+ TIXMLASSERT( _attributePool.CurrentAllocs() == _attributePool.Untracked() );
+ TIXMLASSERT( _textPool.CurrentAllocs() == _textPool.Untracked() );
+ TIXMLASSERT( _commentPool.CurrentAllocs() == _commentPool.Untracked() );
+ }
#endif
}
-void XMLDocument::Clear()
+void XMLDocument::DeepCopy(XMLDocument* target) const
{
- DeleteChildren();
-
- _errorID = XML_NO_ERROR;
- _errorStr1 = 0;
- _errorStr2 = 0;
+ TIXMLASSERT(target);
+ if (target == this) {
+ return; // technically success - a no-op.
+ }
- delete [] _charBuffer;
- _charBuffer = 0;
+ target->Clear();
+ for (const XMLNode* node = this->FirstChild(); node; node = node->NextSibling()) {
+ target->InsertEndChild(node->DeepClone(target));
+ }
}
-
XMLElement* XMLDocument::NewElement( const char* name )
{
- XMLElement* ele = new (_elementPool.Alloc()) XMLElement( this );
- ele->_memPool = &_elementPool;
+ XMLElement* ele = CreateUnlinkedNode<XMLElement>( _elementPool );
ele->SetName( name );
return ele;
}
@@ -1664,8 +2101,7 @@ XMLElement* XMLDocument::NewElement( const char* name )
XMLComment* XMLDocument::NewComment( const char* str )
{
- XMLComment* comment = new (_commentPool.Alloc()) XMLComment( this );
- comment->_memPool = &_commentPool;
+ XMLComment* comment = CreateUnlinkedNode<XMLComment>( _commentPool );
comment->SetValue( str );
return comment;
}
@@ -1673,8 +2109,7 @@ XMLComment* XMLDocument::NewComment( const char* str )
XMLText* XMLDocument::NewText( const char* str )
{
- XMLText* text = new (_textPool.Alloc()) XMLText( this );
- text->_memPool = &_textPool;
+ XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
text->SetValue( str );
return text;
}
@@ -1682,8 +2117,7 @@ XMLText* XMLDocument::NewText( const char* str )
XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
{
- XMLDeclaration* dec = new (_commentPool.Alloc()) XMLDeclaration( this );
- dec->_memPool = &_commentPool;
+ XMLDeclaration* dec = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );
return dec;
}
@@ -1691,14 +2125,15 @@ XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
XMLUnknown* XMLDocument::NewUnknown( const char* str )
{
- XMLUnknown* unk = new (_commentPool.Alloc()) XMLUnknown( this );
- unk->_memPool = &_commentPool;
+ XMLUnknown* unk = CreateUnlinkedNode<XMLUnknown>( _commentPool );
unk->SetValue( str );
return unk;
}
static FILE* callfopen( const char* filepath, const char* mode )
{
+ TIXMLASSERT( filepath );
+ TIXMLASSERT( mode );
#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
FILE* fp = 0;
errno_t err = fopen_s( &fp, filepath, mode );
@@ -1711,12 +2146,36 @@ static FILE* callfopen( const char* filepath, const char* mode )
return fp;
}
+void XMLDocument::DeleteNode( XMLNode* node ) {
+ TIXMLASSERT( node );
+ TIXMLASSERT(node->_document == this );
+ if (node->_parent) {
+ node->_parent->DeleteChild( node );
+ }
+ else {
+ // Isn't in the tree.
+ // Use the parent delete.
+ // Also, we need to mark it tracked: we 'know'
+ // it was never used.
+ node->_memPool->SetTracked();
+ // Call the static XMLNode version:
+ XMLNode::DeleteNode(node);
+ }
+}
+
+
XMLError XMLDocument::LoadFile( const char* filename )
{
+ if ( !filename ) {
+ TIXMLASSERT( false );
+ SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
+ return _errorID;
+ }
+
Clear();
FILE* fp = callfopen( filename, "rb" );
if ( !fp ) {
- SetError( XML_ERROR_FILE_NOT_FOUND, filename, 0 );
+ SetError( XML_ERROR_FILE_NOT_FOUND, 0, "filename=%s", filename );
return _errorID;
}
LoadFile( fp );
@@ -1724,6 +2183,28 @@ XMLError XMLDocument::LoadFile( const char* filename )
return _errorID;
}
+// This is likely overengineered template art to have a check that unsigned long value incremented
+// by one still fits into size_t. If size_t type is larger than unsigned long type
+// (x86_64-w64-mingw32 target) then the check is redundant and gcc and clang emit
+// -Wtype-limits warning. This piece makes the compiler select code with a check when a check
+// is useful and code with no check when a check is redundant depending on how size_t and unsigned long
+// types sizes relate to each other.
+template
+<bool = (sizeof(unsigned long) >= sizeof(size_t))>
+struct LongFitsIntoSizeTMinusOne {
+ static bool Fits( unsigned long value )
+ {
+ return value < (size_t)-1;
+ }
+};
+
+template <>
+struct LongFitsIntoSizeTMinusOne<false> {
+ static bool Fits( unsigned long )
+ {
+ return true;
+ }
+};
XMLError XMLDocument::LoadFile( FILE* fp )
{
@@ -1742,13 +2223,21 @@ XMLError XMLDocument::LoadFile( FILE* fp )
SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
return _errorID;
}
+ TIXMLASSERT( filelength >= 0 );
- const size_t size = filelength;
- if ( size == 0 ) {
+ if ( !LongFitsIntoSizeTMinusOne<>::Fits( filelength ) ) {
+ // Cannot handle files which won't fit in buffer together with null terminator
+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+ return _errorID;
+ }
+
+ if ( filelength == 0 ) {
SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
return _errorID;
}
+ const size_t size = filelength;
+ TIXMLASSERT( _charBuffer == 0 );
_charBuffer = new char[size+1];
size_t read = fread( _charBuffer, 1, size, fp );
if ( read != size ) {
@@ -1758,24 +2247,22 @@ XMLError XMLDocument::LoadFile( FILE* fp )
_charBuffer[size] = 0;
- const char* p = _charBuffer;
- p = XMLUtil::SkipWhiteSpace( p );
- p = XMLUtil::ReadBOM( p, &_writeBOM );
- if ( !p || !*p ) {
- SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
- return _errorID;
- }
-
- ParseDeep( _charBuffer + (p-_charBuffer), 0 );
+ Parse();
return _errorID;
}
XMLError XMLDocument::SaveFile( const char* filename, bool compact )
{
+ if ( !filename ) {
+ TIXMLASSERT( false );
+ SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
+ return _errorID;
+ }
+
FILE* fp = callfopen( filename, "w" );
if ( !fp ) {
- SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, filename, 0 );
+ SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=%s", filename );
return _errorID;
}
SaveFile(fp, compact);
@@ -1786,6 +2273,9 @@ XMLError XMLDocument::SaveFile( const char* filename, bool compact )
XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
{
+ // Clear any error from the last save, otherwise it will get reported
+ // for *this* call.
+ ClearError();
XMLPrinter stream( fp, compact );
Print( &stream );
return _errorID;
@@ -1794,7 +2284,6 @@ XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
XMLError XMLDocument::Parse( const char* p, size_t len )
{
- const char* start = p;
Clear();
if ( len == 0 || !p || !*p ) {
@@ -1804,88 +2293,144 @@ XMLError XMLDocument::Parse( const char* p, size_t len )
if ( len == (size_t)(-1) ) {
len = strlen( p );
}
+ TIXMLASSERT( _charBuffer == 0 );
_charBuffer = new char[ len+1 ];
memcpy( _charBuffer, p, len );
_charBuffer[len] = 0;
- p = XMLUtil::SkipWhiteSpace( p );
- p = XMLUtil::ReadBOM( p, &_writeBOM );
- if ( !p || !*p ) {
- SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
- return _errorID;
+ Parse();
+ if ( Error() ) {
+ // clean up now essentially dangling memory.
+ // and the parse fail can put objects in the
+ // pools that are dead and inaccessible.
+ DeleteChildren();
+ _elementPool.Clear();
+ _attributePool.Clear();
+ _textPool.Clear();
+ _commentPool.Clear();
}
-
- ptrdiff_t delta = p - start; // skip initial whitespace, BOM, etc.
- ParseDeep( _charBuffer+delta, 0 );
return _errorID;
}
void XMLDocument::Print( XMLPrinter* streamer ) const
{
- XMLPrinter stdStreamer( stdout );
- if ( !streamer ) {
- streamer = &stdStreamer;
+ if ( streamer ) {
+ Accept( streamer );
+ }
+ else {
+ XMLPrinter stdoutStreamer( stdout );
+ Accept( &stdoutStreamer );
}
- Accept( streamer );
}
-void XMLDocument::SetError( XMLError error, const char* str1, const char* str2 )
+void XMLDocument::SetError( XMLError error, int lineNum, const char* format, ... )
{
+ TIXMLASSERT( error >= 0 && error < XML_ERROR_COUNT );
_errorID = error;
- _errorStr1 = str1;
- _errorStr2 = str2;
+ _errorLineNum = lineNum;
+ _errorStr.Reset();
+
+ size_t BUFFER_SIZE = 1000;
+ char* buffer = new char[BUFFER_SIZE];
+
+ TIXMLASSERT(sizeof(error) <= sizeof(int));
+ TIXML_SNPRINTF(buffer, BUFFER_SIZE, "Error=%s ErrorID=%d (0x%x) Line number=%d", ErrorIDToName(error), int(error), int(error), lineNum);
+
+ if (format) {
+ size_t len = strlen(buffer);
+ TIXML_SNPRINTF(buffer + len, BUFFER_SIZE - len, ": ");
+ len = strlen(buffer);
+
+ va_list va;
+ va_start(va, format);
+ TIXML_VSNPRINTF(buffer + len, BUFFER_SIZE - len, format, va);
+ va_end(va);
+ }
+ _errorStr.SetStr(buffer);
+ delete[] buffer;
}
-const char* XMLDocument::ErrorName() const
+
+/*static*/ const char* XMLDocument::ErrorIDToName(XMLError errorID)
{
- TIXMLASSERT(_errorID >= 0 && _errorID < XML_ERROR_COUNT );
- return _errorNames[_errorID];
+ TIXMLASSERT( errorID >= 0 && errorID < XML_ERROR_COUNT );
+ const char* errorName = _errorNames[errorID];
+ TIXMLASSERT( errorName && errorName[0] );
+ return errorName;
}
+const char* XMLDocument::ErrorStr() const
+{
+ return _errorStr.Empty() ? "" : _errorStr.GetStr();
+}
+
+
void XMLDocument::PrintError() const
{
- if ( _errorID ) {
- static const int LEN = 20;
- char buf1[LEN] = { 0 };
- char buf2[LEN] = { 0 };
+ printf("%s\n", ErrorStr());
+}
- if ( _errorStr1 ) {
- TIXML_SNPRINTF( buf1, LEN, "%s", _errorStr1 );
- }
- if ( _errorStr2 ) {
- TIXML_SNPRINTF( buf2, LEN, "%s", _errorStr2 );
- }
+const char* XMLDocument::ErrorName() const
+{
+ return ErrorIDToName(_errorID);
+}
- printf( "XMLDocument error id=%d '%s' str1=%s str2=%s\n",
- _errorID, ErrorName(), buf1, buf2 );
+void XMLDocument::Parse()
+{
+ TIXMLASSERT( NoChildren() ); // Clear() must have been called previously
+ TIXMLASSERT( _charBuffer );
+ _parseCurLineNum = 1;
+ _parseLineNum = 1;
+ char* p = _charBuffer;
+ p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
+ p = const_cast<char*>( XMLUtil::ReadBOM( p, &_writeBOM ) );
+ if ( !*p ) {
+ SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
+ return;
}
+ ParseDeep(p, 0, &_parseCurLineNum );
+}
+
+void XMLDocument::PushDepth()
+{
+ _parsingDepth++;
+ if (_parsingDepth == TINYXML2_MAX_ELEMENT_DEPTH) {
+ SetError(XML_ELEMENT_DEPTH_EXCEEDED, _parseCurLineNum, "Element nesting is too deep." );
+ }
}
+void XMLDocument::PopDepth()
+{
+ TIXMLASSERT(_parsingDepth > 0);
+ --_parsingDepth;
+}
XMLPrinter::XMLPrinter( FILE* file, bool compact, int depth ) :
_elementJustOpened( false ),
+ _stack(),
_firstElement( true ),
_fp( file ),
_depth( depth ),
_textDepth( -1 ),
_processEntities( true ),
- _compactMode( compact )
+ _compactMode( compact ),
+ _buffer()
{
for( int i=0; i<ENTITY_RANGE; ++i ) {
_entityFlag[i] = false;
_restrictedEntityFlag[i] = false;
}
for( int i=0; i<NUM_ENTITIES; ++i ) {
- TIXMLASSERT( entities[i].value < ENTITY_RANGE );
- if ( entities[i].value < ENTITY_RANGE ) {
- _entityFlag[ (int)entities[i].value ] = true;
- }
- }
- _restrictedEntityFlag[(int)'&'] = true;
- _restrictedEntityFlag[(int)'<'] = true;
- _restrictedEntityFlag[(int)'>'] = true; // not required, but consistency is nice
+ const char entityValue = entities[i].value;
+ const unsigned char flagIndex = (unsigned char)entityValue;
+ TIXMLASSERT( flagIndex < ENTITY_RANGE );
+ _entityFlag[flagIndex] = true;
+ }
+ _restrictedEntityFlag[(unsigned char)'&'] = true;
+ _restrictedEntityFlag[(unsigned char)'<'] = true;
+ _restrictedEntityFlag[(unsigned char)'>'] = true; // not required, but consistency is nice
_buffer.Push( 0 );
}
@@ -1899,43 +2444,49 @@ void XMLPrinter::Print( const char* format, ... )
vfprintf( _fp, format, va );
}
else {
-#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
- #if defined(WINCE)
- int len = 512;
- do {
- len = len*2;
- char* str = new char[len]();
- len = _vsnprintf(str, len, format, va);
- delete[] str;
- }while (len < 0);
- #else
- int len = _vscprintf( format, va );
- #endif
-#else
- int len = vsnprintf( 0, 0, format, va );
-#endif
+ const int len = TIXML_VSCPRINTF( format, va );
// Close out and re-start the va-args
va_end( va );
+ TIXMLASSERT( len >= 0 );
va_start( va, format );
+ TIXMLASSERT( _buffer.Size() > 0 && _buffer[_buffer.Size() - 1] == 0 );
char* p = _buffer.PushArr( len ) - 1; // back up over the null terminator.
-#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
- #if defined(WINCE)
- _vsnprintf( p, len+1, format, va );
- #else
- vsnprintf_s( p, len+1, _TRUNCATE, format, va );
- #endif
-#else
- vsnprintf( p, len+1, format, va );
-#endif
+ TIXML_VSNPRINTF( p, len+1, format, va );
}
va_end( va );
}
+void XMLPrinter::Write( const char* data, size_t size )
+{
+ if ( _fp ) {
+ fwrite ( data , sizeof(char), size, _fp);
+ }
+ else {
+ char* p = _buffer.PushArr( static_cast<int>(size) ) - 1; // back up over the null terminator.
+ memcpy( p, data, size );
+ p[size] = 0;
+ }
+}
+
+
+void XMLPrinter::Putc( char ch )
+{
+ if ( _fp ) {
+ fputc ( ch, _fp);
+ }
+ else {
+ char* p = _buffer.PushArr( sizeof(char) ) - 1; // back up over the null terminator.
+ p[0] = ch;
+ p[1] = 0;
+ }
+}
+
+
void XMLPrinter::PrintSpace( int depth )
{
for( int i=0; i<depth; ++i ) {
- Print( " " );
+ Write( " " );
}
}
@@ -1944,36 +2495,53 @@ void XMLPrinter::PrintString( const char* p, bool restricted )
{
// Look for runs of bytes between entities to print.
const char* q = p;
- const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
if ( _processEntities ) {
+ const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
while ( *q ) {
+ TIXMLASSERT( p <= q );
// Remember, char is sometimes signed. (How many times has that bitten me?)
if ( *q > 0 && *q < ENTITY_RANGE ) {
// Check for entities. If one is found, flush
// the stream up until the entity, write the
// entity, and keep looking.
- if ( flag[(unsigned)(*q)] ) {
+ if ( flag[(unsigned char)(*q)] ) {
while ( p < q ) {
- Print( "%c", *p );
- ++p;
+ const size_t delta = q - p;
+ const int toPrint = ( INT_MAX < delta ) ? INT_MAX : (int)delta;
+ Write( p, toPrint );
+ p += toPrint;
}
+ bool entityPatternPrinted = false;
for( int i=0; i<NUM_ENTITIES; ++i ) {
if ( entities[i].value == *q ) {
- Print( "&%s;", entities[i].pattern );
+ Putc( '&' );
+ Write( entities[i].pattern, entities[i].length );
+ Putc( ';' );
+ entityPatternPrinted = true;
break;
}
}
+ if ( !entityPatternPrinted ) {
+ // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release
+ TIXMLASSERT( false );
+ }
++p;
}
}
++q;
+ TIXMLASSERT( p <= q );
+ }
+ // Flush the remaining string. This will be the entire
+ // string if an entity wasn't found.
+ if ( p < q ) {
+ const size_t delta = q - p;
+ const int toPrint = ( INT_MAX < delta ) ? INT_MAX : (int)delta;
+ Write( p, toPrint );
}
}
- // Flush the remaining string. This will be the entire
- // string if an entity wasn't found.
- if ( !_processEntities || (q-p > 0) ) {
- Print( "%s", p );
+ else {
+ Write( p );
}
}
@@ -1982,7 +2550,7 @@ void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
{
if ( writeBOM ) {
static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
- Print( "%s", bom );
+ Write( reinterpret_cast< const char* >( bom ) );
}
if ( writeDec ) {
PushDeclaration( "xml version=\"1.0\"" );
@@ -1992,19 +2560,19 @@ void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
void XMLPrinter::OpenElement( const char* name, bool compactMode )
{
- if ( _elementJustOpened ) {
- SealElement();
- }
+ SealElementIfJustOpened();
_stack.Push( name );
if ( _textDepth < 0 && !_firstElement && !compactMode ) {
- Print( "\n" );
+ Putc( '\n' );
}
if ( !compactMode ) {
PrintSpace( _depth );
}
- Print( "<%s", name );
+ Write ( "<" );
+ Write ( name );
+
_elementJustOpened = true;
_firstElement = false;
++_depth;
@@ -2014,9 +2582,11 @@ void XMLPrinter::OpenElement( const char* name, bool compactMode )
void XMLPrinter::PushAttribute( const char* name, const char* value )
{
TIXMLASSERT( _elementJustOpened );
- Print( " %s=\"", name );
+ Putc ( ' ' );
+ Write( name );
+ Write( "=\"" );
PrintString( value, false );
- Print( "\"" );
+ Putc ( '\"' );
}
@@ -2036,6 +2606,14 @@ void XMLPrinter::PushAttribute( const char* name, unsigned v )
}
+void XMLPrinter::PushAttribute(const char* name, int64_t v)
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ PushAttribute(name, buf);
+}
+
+
void XMLPrinter::PushAttribute( const char* name, bool v )
{
char buf[BUF_SIZE];
@@ -2058,30 +2636,35 @@ void XMLPrinter::CloseElement( bool compactMode )
const char* name = _stack.Pop();
if ( _elementJustOpened ) {
- Print( "/>" );
+ Write( "/>" );
}
else {
if ( _textDepth < 0 && !compactMode) {
- Print( "\n" );
+ Putc( '\n' );
PrintSpace( _depth );
}
- Print( "</%s>", name );
+ Write ( "</" );
+ Write ( name );
+ Write ( ">" );
}
if ( _textDepth == _depth ) {
_textDepth = -1;
}
if ( _depth == 0 && !compactMode) {
- Print( "\n" );
+ Putc( '\n' );
}
_elementJustOpened = false;
}
-void XMLPrinter::SealElement()
+void XMLPrinter::SealElementIfJustOpened()
{
+ if ( !_elementJustOpened ) {
+ return;
+ }
_elementJustOpened = false;
- Print( ">" );
+ Putc( '>' );
}
@@ -2089,19 +2672,24 @@ void XMLPrinter::PushText( const char* text, bool cdata )
{
_textDepth = _depth-1;
- if ( _elementJustOpened ) {
- SealElement();
- }
+ SealElementIfJustOpened();
if ( cdata ) {
- Print( "<![CDATA[" );
- Print( "%s", text );
- Print( "]]>" );
+ Write( "<![CDATA[" );
+ Write( text );
+ Write( "]]>" );
}
else {
PrintString( text, true );
}
}
+void XMLPrinter::PushText( int64_t value )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( value, buf, BUF_SIZE );
+ PushText( buf, false );
+}
+
void XMLPrinter::PushText( int value )
{
char buf[BUF_SIZE];
@@ -2144,43 +2732,46 @@ void XMLPrinter::PushText( double value )
void XMLPrinter::PushComment( const char* comment )
{
- if ( _elementJustOpened ) {
- SealElement();
- }
+ SealElementIfJustOpened();
if ( _textDepth < 0 && !_firstElement && !_compactMode) {
- Print( "\n" );
+ Putc( '\n' );
PrintSpace( _depth );
}
_firstElement = false;
- Print( "<!--%s-->", comment );
+
+ Write( "<!--" );
+ Write( comment );
+ Write( "-->" );
}
void XMLPrinter::PushDeclaration( const char* value )
{
- if ( _elementJustOpened ) {
- SealElement();
- }
+ SealElementIfJustOpened();
if ( _textDepth < 0 && !_firstElement && !_compactMode) {
- Print( "\n" );
+ Putc( '\n' );
PrintSpace( _depth );
}
_firstElement = false;
- Print( "<?%s?>", value );
+
+ Write( "<?" );
+ Write( value );
+ Write( "?>" );
}
void XMLPrinter::PushUnknown( const char* value )
{
- if ( _elementJustOpened ) {
- SealElement();
- }
+ SealElementIfJustOpened();
if ( _textDepth < 0 && !_firstElement && !_compactMode) {
- Print( "\n" );
+ Putc( '\n' );
PrintSpace( _depth );
}
_firstElement = false;
- Print( "<!%s>", value );
+
+ Write( "<!" );
+ Write( value );
+ Putc( '>' );
}
@@ -2196,8 +2787,11 @@ bool XMLPrinter::VisitEnter( const XMLDocument& doc )
bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
{
- const XMLElement* parentElem = element.Parent()->ToElement();
- bool compactMode = parentElem ? CompactMode(*parentElem) : _compactMode;
+ const XMLElement* parentElem = 0;
+ if ( element.Parent() ) {
+ parentElem = element.Parent()->ToElement();
+ }
+ const bool compactMode = parentElem ? CompactMode( *parentElem ) : _compactMode;
OpenElement( element.Name(), compactMode );
while ( attribute ) {
PushAttribute( attribute->Name(), attribute->Value() );
@@ -2241,4 +2835,3 @@ bool XMLPrinter::Visit( const XMLUnknown& unknown )
}
} // namespace tinyxml2
-
diff --git a/tests/xmltester/tinyxml2/tinyxml2.h b/tests/xmltester/tinyxml2/tinyxml2.h
index cfb2d65..5e3274f 100755
--- a/tests/xmltester/tinyxml2/tinyxml2.h
+++ b/tests/xmltester/tinyxml2/tinyxml2.h
@@ -14,7 +14,6 @@ not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.
-
2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.
@@ -25,36 +24,38 @@ distribution.
#ifndef TINYXML2_INCLUDED
#define TINYXML2_INCLUDED
-#if defined(ANDROID_NDK) || defined(__BORLANDC__)
+#if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__)
# include <ctype.h>
# include <limits.h>
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
-# include <stdarg.h>
+# if defined(__PS3__)
+# include <stddef.h>
+# endif
#else
# include <cctype>
# include <climits>
# include <cstdio>
# include <cstdlib>
# include <cstring>
-# include <cstdarg>
#endif
+#include <stdint.h>
/*
TODO: intern strings instead of allocation.
*/
/*
gcc:
- g++ -Wall -DDEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
+ g++ -Wall -DTINYXML2_DEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
Formatting, Artistic Style:
AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
*/
-#if defined( _DEBUG ) || defined( DEBUG ) || defined (__DEBUG__)
-# ifndef DEBUG
-# define DEBUG
+#if defined( _DEBUG ) || defined (__DEBUG__)
+# ifndef TINYXML2_DEBUG
+# define TINYXML2_DEBUG
# endif
#endif
@@ -71,14 +72,17 @@ distribution.
# else
# define TINYXML2_LIB
# endif
+#elif __GNUC__ >= 4
+# define TINYXML2_LIB __attribute__((visibility("default")))
#else
# define TINYXML2_LIB
#endif
-#if defined(DEBUG)
+#if defined(TINYXML2_DEBUG)
# if defined(_MSC_VER)
-# define TIXMLASSERT( x ) if ( !(x)) { __debugbreak(); } //if ( !(x)) WinDebugBreak()
+# // "(void)0," is for suppressing C4127 warning in "assert(false)", "assert(true)" and the like
+# define TIXMLASSERT( x ) if ( !((void)0,(x))) { __debugbreak(); }
# elif defined (ANDROID_NDK)
# include <android/log.h>
# define TIXMLASSERT( x ) if ( !(x)) { __android_log_assert( "assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__ ); }
@@ -86,46 +90,29 @@ distribution.
# include <assert.h>
# define TIXMLASSERT assert
# endif
-# else
-# define TIXMLASSERT( x ) {}
-#endif
-
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
-// Microsoft visual studio, version 2005 and higher.
-/*int _snprintf_s(
- char *buffer,
- size_t sizeOfBuffer,
- size_t count,
- const char *format [,
- argument] ...
-);*/
-inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
-{
- va_list va;
- va_start( va, format );
- int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
- va_end( va );
- return result;
-}
-#define TIXML_SSCANF sscanf_s
-#elif defined WINCE
-#define TIXML_SNPRINTF _snprintf
-#define TIXML_SSCANF sscanf
#else
-// GCC version 3 and higher
-//#warning( "Using sn* functions." )
-#define TIXML_SNPRINTF snprintf
-#define TIXML_SSCANF sscanf
+# define TIXMLASSERT( x ) {}
#endif
+
/* Versioning, past 1.0.14:
http://semver.org/
*/
-static const int TIXML2_MAJOR_VERSION = 2;
-static const int TIXML2_MINOR_VERSION = 2;
+static const int TIXML2_MAJOR_VERSION = 7;
+static const int TIXML2_MINOR_VERSION = 0;
static const int TIXML2_PATCH_VERSION = 0;
+#define TINYXML2_MAJOR_VERSION 7
+#define TINYXML2_MINOR_VERSION 0
+#define TINYXML2_PATCH_VERSION 0
+
+// A fixed element depth limit is problematic. There needs to be a
+// limit to avoid a stack overflow. However, that limit varies per
+// system, and the capacity of the stack. On the other hand, it's a trivial
+// attack that can result from ill, malicious, or even correctly formed XML,
+// so there needs to be a limit in place.
+static const int TINYXML2_MAX_ELEMENT_DEPTH = 100;
+
namespace tinyxml2
{
class XMLDocument;
@@ -149,20 +136,22 @@ public:
enum {
NEEDS_ENTITY_PROCESSING = 0x01,
NEEDS_NEWLINE_NORMALIZATION = 0x02,
- COLLAPSE_WHITESPACE = 0x04,
+ NEEDS_WHITESPACE_COLLAPSING = 0x04,
- TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+ TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
- ATTRIBUTE_NAME = 0,
- ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
- ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
- COMMENT = NEEDS_NEWLINE_NORMALIZATION
+ ATTRIBUTE_NAME = 0,
+ ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+ ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
+ COMMENT = NEEDS_NEWLINE_NORMALIZATION
};
StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
~StrPair();
void Set( char* start, char* end, int flags ) {
+ TIXMLASSERT( start );
+ TIXMLASSERT( end );
Reset();
_start = start;
_end = end;
@@ -182,11 +171,13 @@ public:
void SetStr( const char* str, int flags=0 );
- char* ParseText( char* in, const char* endTag, int strFlags );
+ char* ParseText( char* in, const char* endTag, int strFlags, int* curLineNumPtr );
char* ParseName( char* in );
+ void TransferTo( StrPair* other );
+ void Reset();
+
private:
- void Reset();
void CollapseWhitespace();
enum {
@@ -194,10 +185,12 @@ private:
NEEDS_DELETE = 0x200
};
- // After parsing, if *_end != 0, it can be set to zero.
int _flags;
char* _start;
char* _end;
+
+ StrPair( const StrPair& other ); // not supported
+ void operator=( const StrPair& other ); // not supported, use TransferTo()
};
@@ -206,14 +199,15 @@ private:
Has a small initial memory pool, so that low or no usage will not
cause a call to new/delete
*/
-template <class T, int INIT>
+template <class T, int INITIAL_SIZE>
class DynArray
{
public:
- DynArray< T, INIT >() {
- _mem = _pool;
- _allocated = INIT;
- _size = 0;
+ DynArray() :
+ _mem( _pool ),
+ _allocated( INITIAL_SIZE ),
+ _size( 0 )
+ {
}
~DynArray() {
@@ -227,11 +221,15 @@ public:
}
void Push( T t ) {
+ TIXMLASSERT( _size < INT_MAX );
EnsureCapacity( _size+1 );
- _mem[_size++] = t;
+ _mem[_size] = t;
+ ++_size;
}
T* PushArr( int count ) {
+ TIXMLASSERT( count >= 0 );
+ TIXMLASSERT( _size <= INT_MAX - count );
EnsureCapacity( _size+count );
T* ret = &_mem[_size];
_size += count;
@@ -239,7 +237,9 @@ public:
}
T Pop() {
- return _mem[--_size];
+ TIXMLASSERT( _size > 0 );
+ --_size;
+ return _mem[_size];
}
void PopArr( int count ) {
@@ -261,32 +261,49 @@ public:
return _mem[i];
}
- const T& PeekTop() const {
+ const T& PeekTop() const {
TIXMLASSERT( _size > 0 );
return _mem[ _size - 1];
}
int Size() const {
+ TIXMLASSERT( _size >= 0 );
return _size;
}
int Capacity() const {
+ TIXMLASSERT( _allocated >= INITIAL_SIZE );
return _allocated;
}
+ void SwapRemove(int i) {
+ TIXMLASSERT(i >= 0 && i < _size);
+ TIXMLASSERT(_size > 0);
+ _mem[i] = _mem[_size - 1];
+ --_size;
+ }
+
const T* Mem() const {
+ TIXMLASSERT( _mem );
return _mem;
}
- T* Mem() {
+ T* Mem() {
+ TIXMLASSERT( _mem );
return _mem;
}
private:
+ DynArray( const DynArray& ); // not supported
+ void operator=( const DynArray& ); // not supported
+
void EnsureCapacity( int cap ) {
+ TIXMLASSERT( cap > 0 );
if ( cap > _allocated ) {
+ TIXMLASSERT( cap <= INT_MAX / 2 );
int newAllocated = cap * 2;
T* newMem = new T[newAllocated];
+ TIXMLASSERT( newAllocated >= _size );
memcpy( newMem, _mem, sizeof(T)*_size ); // warning: not using constructors, only works for PODs
if ( _mem != _pool ) {
delete [] _mem;
@@ -297,7 +314,7 @@ private:
}
T* _mem;
- T _pool[INIT];
+ T _pool[INITIAL_SIZE];
int _allocated; // objects allocated
int _size; // number objects in use
};
@@ -323,20 +340,30 @@ public:
/*
Template child class to create pools of the correct type.
*/
-template< int SIZE >
+template< int ITEM_SIZE >
class MemPoolT : public MemPool
{
public:
- MemPoolT() : _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
+ MemPoolT() : _blockPtrs(), _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
~MemPoolT() {
+ MemPoolT< ITEM_SIZE >::Clear();
+ }
+
+ void Clear() {
// Delete the blocks.
- for( int i=0; i<_blockPtrs.Size(); ++i ) {
- delete _blockPtrs[i];
+ while( !_blockPtrs.Empty()) {
+ Block* lastBlock = _blockPtrs.Pop();
+ delete lastBlock;
}
+ _root = 0;
+ _currentAllocs = 0;
+ _nAllocs = 0;
+ _maxAllocs = 0;
+ _nUntracked = 0;
}
virtual int ItemSize() const {
- return SIZE;
+ return ITEM_SIZE;
}
int CurrentAllocs() const {
return _currentAllocs;
@@ -348,42 +375,46 @@ public:
Block* block = new Block();
_blockPtrs.Push( block );
- for( int i=0; i<COUNT-1; ++i ) {
- block->chunk[i].next = &block->chunk[i+1];
+ Item* blockItems = block->items;
+ for( int i = 0; i < ITEMS_PER_BLOCK - 1; ++i ) {
+ blockItems[i].next = &(blockItems[i + 1]);
}
- block->chunk[COUNT-1].next = 0;
- _root = block->chunk;
+ blockItems[ITEMS_PER_BLOCK - 1].next = 0;
+ _root = blockItems;
}
- void* result = _root;
+ Item* const result = _root;
+ TIXMLASSERT( result != 0 );
_root = _root->next;
++_currentAllocs;
if ( _currentAllocs > _maxAllocs ) {
_maxAllocs = _currentAllocs;
}
- _nAllocs++;
- _nUntracked++;
+ ++_nAllocs;
+ ++_nUntracked;
return result;
}
+
virtual void Free( void* mem ) {
if ( !mem ) {
return;
}
--_currentAllocs;
- Chunk* chunk = static_cast<Chunk*>( mem );
-#ifdef DEBUG
- memset( chunk, 0xfe, sizeof(Chunk) );
+ Item* item = static_cast<Item*>( mem );
+#ifdef TINYXML2_DEBUG
+ memset( item, 0xfe, sizeof( *item ) );
#endif
- chunk->next = _root;
- _root = chunk;
+ item->next = _root;
+ _root = item;
}
void Trace( const char* name ) {
printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
- name, _maxAllocs, _maxAllocs*SIZE/1024, _currentAllocs, SIZE, _nAllocs, _blockPtrs.Size() );
+ name, _maxAllocs, _maxAllocs * ITEM_SIZE / 1024, _currentAllocs,
+ ITEM_SIZE, _nAllocs, _blockPtrs.Size() );
}
void SetTracked() {
- _nUntracked--;
+ --_nUntracked;
}
int Untracked() const {
@@ -399,18 +430,23 @@ public:
// 16k: 5200
// 32k: 4300
// 64k: 4000 21000
- enum { COUNT = (4*1024)/SIZE }; // Some compilers do not accept to use COUNT in private part if COUNT is private
+ // Declared public because some compilers do not accept to use ITEMS_PER_BLOCK
+ // in private part if ITEMS_PER_BLOCK is private
+ enum { ITEMS_PER_BLOCK = (4 * 1024) / ITEM_SIZE };
private:
- union Chunk {
- Chunk* next;
- char mem[SIZE];
+ MemPoolT( const MemPoolT& ); // not supported
+ void operator=( const MemPoolT& ); // not supported
+
+ union Item {
+ Item* next;
+ char itemData[ITEM_SIZE];
};
struct Block {
- Chunk chunk[COUNT];
+ Item items[ITEMS_PER_BLOCK];
};
DynArray< Block*, 10 > _blockPtrs;
- Chunk* _root;
+ Item* _root;
int _currentAllocs;
int _nAllocs;
@@ -480,19 +516,16 @@ public:
}
};
-// WARNING: must match XMLErrorNames[]
+// WARNING: must match XMLDocument::_errorNames[]
enum XMLError {
XML_SUCCESS = 0,
- XML_NO_ERROR = 0,
XML_NO_ATTRIBUTE,
XML_WRONG_ATTRIBUTE_TYPE,
XML_ERROR_FILE_NOT_FOUND,
XML_ERROR_FILE_COULD_NOT_BE_OPENED,
XML_ERROR_FILE_READ_ERROR,
- XML_ERROR_ELEMENT_MISMATCH,
XML_ERROR_PARSING_ELEMENT,
XML_ERROR_PARSING_ATTRIBUTE,
- XML_ERROR_IDENTIFYING_TAG,
XML_ERROR_PARSING_TEXT,
XML_ERROR_PARSING_CDATA,
XML_ERROR_PARSING_COMMENT,
@@ -503,6 +536,7 @@ enum XMLError {
XML_ERROR_PARSING,
XML_CAN_NOT_CONVERT_TEXT,
XML_NO_TEXT_NODE,
+ XML_ELEMENT_DEPTH_EXCEEDED,
XML_ERROR_COUNT
};
@@ -511,33 +545,42 @@ enum XMLError {
/*
Utility functionality.
*/
-class XMLUtil
+class TINYXML2_LIB XMLUtil
{
public:
- // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
- // correct, but simple, and usually works.
- static const char* SkipWhiteSpace( const char* p ) {
- while( !IsUTF8Continuation(*p) && isspace( *reinterpret_cast<const unsigned char*>(p) ) ) {
+ static const char* SkipWhiteSpace( const char* p, int* curLineNumPtr ) {
+ TIXMLASSERT( p );
+
+ while( IsWhiteSpace(*p) ) {
+ if (curLineNumPtr && *p == '\n') {
+ ++(*curLineNumPtr);
+ }
++p;
}
+ TIXMLASSERT( p );
return p;
}
- static char* SkipWhiteSpace( char* p ) {
- while( !IsUTF8Continuation(*p) && isspace( *reinterpret_cast<unsigned char*>(p) ) ) {
- ++p;
- }
- return p;
+ static char* SkipWhiteSpace( char* p, int* curLineNumPtr ) {
+ return const_cast<char*>( SkipWhiteSpace( const_cast<const char*>(p), curLineNumPtr ) );
}
+
+ // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
+ // correct, but simple, and usually works.
static bool IsWhiteSpace( char p ) {
return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
}
-
+
inline static bool IsNameStartChar( unsigned char ch ) {
- return ( ( ch < 128 ) ? isalpha( ch ) : 1 )
- || ch == ':'
- || ch == '_';
+ if ( ch >= 128 ) {
+ // This is a heuristic guess in attempt to not implement Unicode-aware isalpha()
+ return true;
+ }
+ if ( isalpha( ch ) ) {
+ return true;
+ }
+ return ch == ':' || ch == '_';
}
-
+
inline static bool IsNameChar( unsigned char ch ) {
return IsNameStartChar( ch )
|| isdigit( ch )
@@ -546,23 +589,17 @@ public:
}
inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX ) {
- int n = 0;
if ( p == q ) {
return true;
}
- while( *p && *q && *p == *q && n<nChar ) {
- ++p;
- ++q;
- ++n;
- }
- if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {
- return true;
- }
- return false;
+ TIXMLASSERT( p );
+ TIXMLASSERT( q );
+ TIXMLASSERT( nChar >= 0 );
+ return strncmp( p, q, nChar ) == 0;
}
-
- inline static int IsUTF8Continuation( const char p ) {
- return p & 0x80;
+
+ inline static bool IsUTF8Continuation( char p ) {
+ return ( p & 0x80 ) != 0;
}
static const char* ReadBOM( const char* p, bool* hasBOM );
@@ -577,6 +614,7 @@ public:
static void ToStr( bool v, char* buffer, int bufferSize );
static void ToStr( float v, char* buffer, int bufferSize );
static void ToStr( double v, char* buffer, int bufferSize );
+ static void ToStr(int64_t v, char* buffer, int bufferSize);
// converts strings to primitive types
static bool ToInt( const char* str, int* value );
@@ -584,6 +622,18 @@ public:
static bool ToBool( const char* str, bool* value );
static bool ToFloat( const char* str, float* value );
static bool ToDouble( const char* str, double* value );
+ static bool ToInt64(const char* str, int64_t* value);
+
+ // Changes what is serialized for a boolean value.
+ // Default to "true" and "false". Shouldn't be changed
+ // unless you have a special testing or compatibility need.
+ // Be careful: static, global, & not thread safe.
+ // Be sure to set static const memory as parameters.
+ static void SetBoolSerialization(const char* writeTrue, const char* writeFalse);
+
+private:
+ static const char* writeBoolTrue;
+ static const char* writeBoolFalse;
};
@@ -620,10 +670,12 @@ public:
/// Get the XMLDocument that owns this XMLNode.
const XMLDocument* GetDocument() const {
+ TIXMLASSERT( _document );
return _document;
}
/// Get the XMLDocument that owns this XMLNode.
XMLDocument* GetDocument() {
+ TIXMLASSERT( _document );
return _document;
}
@@ -673,7 +725,7 @@ public:
/** The meaning of 'value' changes for the specific type.
@verbatim
- Document: empty
+ Document: empty (NULL is returned, not an empty string)
Element: name of the element
Comment: the comment text
Unknown: the tag contents
@@ -687,6 +739,9 @@ public:
*/
void SetValue( const char* val, bool staticMem=false );
+ /// Gets the line number the node is in, if the document was parsed from a file.
+ int GetLineNum() const { return _parseLineNum; }
+
/// Get the parent of this node on the DOM.
const XMLNode* Parent() const {
return _parent;
@@ -713,10 +768,10 @@ public:
/** Get the first child element, or optionally the first child
element with the specified name.
*/
- const XMLElement* FirstChildElement( const char* value=0 ) const;
+ const XMLElement* FirstChildElement( const char* name = 0 ) const;
- XMLElement* FirstChildElement( const char* value=0 ) {
- return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( value ));
+ XMLElement* FirstChildElement( const char* name = 0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( name ));
}
/// Get the last child node, or null if none exists.
@@ -725,16 +780,16 @@ public:
}
XMLNode* LastChild() {
- return const_cast<XMLNode*>(const_cast<const XMLNode*>(this)->LastChild() );
+ return _lastChild;
}
/** Get the last child element or optionally the last child
element with the specified name.
*/
- const XMLElement* LastChildElement( const char* value=0 ) const;
+ const XMLElement* LastChildElement( const char* name = 0 ) const;
- XMLElement* LastChildElement( const char* value=0 ) {
- return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(value) );
+ XMLElement* LastChildElement( const char* name = 0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(name) );
}
/// Get the previous (left) sibling node of this node.
@@ -747,10 +802,10 @@ public:
}
/// Get the previous (left) sibling element of this node, with an optionally supplied name.
- const XMLElement* PreviousSiblingElement( const char* value=0 ) const ;
+ const XMLElement* PreviousSiblingElement( const char* name = 0 ) const ;
- XMLElement* PreviousSiblingElement( const char* value=0 ) {
- return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( value ) );
+ XMLElement* PreviousSiblingElement( const char* name = 0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( name ) );
}
/// Get the next (right) sibling node of this node.
@@ -763,10 +818,10 @@ public:
}
/// Get the next (right) sibling element of this node, with an optionally supplied name.
- const XMLElement* NextSiblingElement( const char* value=0 ) const;
+ const XMLElement* NextSiblingElement( const char* name = 0 ) const;
- XMLElement* NextSiblingElement( const char* value=0 ) {
- return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( value ) );
+ XMLElement* NextSiblingElement( const char* name = 0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( name ) );
}
/**
@@ -820,6 +875,21 @@ public:
*/
virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
+ /**
+ Make a copy of this node and all its children.
+
+ If the 'target' is null, then the nodes will
+ be allocated in the current document. If 'target'
+ is specified, the memory will be allocated is the
+ specified XMLDocument.
+
+ NOTE: This is probably not the correct tool to
+ copy a document, since XMLDocuments can have multiple
+ top level XMLNodes. You probably want to use
+ XMLDocument::DeepCopy()
+ */
+ XMLNode* DeepClone( XMLDocument* target ) const;
+
/**
Test if 2 nodes are the same, but don't test children.
The 2 nodes do not need to be in the same Document.
@@ -852,18 +922,30 @@ public:
*/
virtual bool Accept( XMLVisitor* visitor ) const = 0;
- // internal
- virtual char* ParseDeep( char*, StrPair* );
+ /**
+ Set user data into the XMLNode. TinyXML-2 in
+ no way processes or interprets user data.
+ It is initially 0.
+ */
+ void SetUserData(void* userData) { _userData = userData; }
+
+ /**
+ Get user data set into the XMLNode. TinyXML-2 in
+ no way processes or interprets user data.
+ It is initially 0.
+ */
+ void* GetUserData() const { return _userData; }
protected:
- XMLNode( XMLDocument* );
+ explicit XMLNode( XMLDocument* );
virtual ~XMLNode();
- XMLNode( const XMLNode& ); // not supported
- XMLNode& operator=( const XMLNode& ); // not supported
+
+ virtual char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr);
XMLDocument* _document;
XMLNode* _parent;
mutable StrPair _value;
+ int _parseLineNum;
XMLNode* _firstChild;
XMLNode* _lastChild;
@@ -871,10 +953,17 @@ protected:
XMLNode* _prev;
XMLNode* _next;
+ void* _userData;
+
private:
MemPool* _memPool;
void Unlink( XMLNode* child );
static void DeleteNode( XMLNode* node );
+ void InsertChildPreamble( XMLNode* insertThis ) const;
+ const XMLElement* ToElementWithName( const char* name ) const;
+
+ XMLNode( const XMLNode& ); // not supported
+ XMLNode& operator=( const XMLNode& ); // not supported
};
@@ -892,7 +981,6 @@ private:
*/
class TINYXML2_LIB XMLText : public XMLNode
{
- friend class XMLBase;
friend class XMLDocument;
public:
virtual bool Accept( XMLVisitor* visitor ) const;
@@ -913,18 +1001,20 @@ public:
return _isCData;
}
- char* ParseDeep( char*, StrPair* endTag );
virtual XMLNode* ShallowClone( XMLDocument* document ) const;
virtual bool ShallowEqual( const XMLNode* compare ) const;
protected:
- XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
+ explicit XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
virtual ~XMLText() {}
- XMLText( const XMLText& ); // not supported
- XMLText& operator=( const XMLText& ); // not supported
+
+ char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
private:
bool _isCData;
+
+ XMLText( const XMLText& ); // not supported
+ XMLText& operator=( const XMLText& ); // not supported
};
@@ -942,17 +1032,18 @@ public:
virtual bool Accept( XMLVisitor* visitor ) const;
- char* ParseDeep( char*, StrPair* endTag );
virtual XMLNode* ShallowClone( XMLDocument* document ) const;
virtual bool ShallowEqual( const XMLNode* compare ) const;
protected:
- XMLComment( XMLDocument* doc );
+ explicit XMLComment( XMLDocument* doc );
virtual ~XMLComment();
- XMLComment( const XMLComment& ); // not supported
- XMLComment& operator=( const XMLComment& ); // not supported
+
+ char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr);
private:
+ XMLComment( const XMLComment& ); // not supported
+ XMLComment& operator=( const XMLComment& ); // not supported
};
@@ -980,13 +1071,16 @@ public:
virtual bool Accept( XMLVisitor* visitor ) const;
- char* ParseDeep( char*, StrPair* endTag );
virtual XMLNode* ShallowClone( XMLDocument* document ) const;
virtual bool ShallowEqual( const XMLNode* compare ) const;
protected:
- XMLDeclaration( XMLDocument* doc );
+ explicit XMLDeclaration( XMLDocument* doc );
virtual ~XMLDeclaration();
+
+ char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
+
+private:
XMLDeclaration( const XMLDeclaration& ); // not supported
XMLDeclaration& operator=( const XMLDeclaration& ); // not supported
};
@@ -1012,13 +1106,16 @@ public:
virtual bool Accept( XMLVisitor* visitor ) const;
- char* ParseDeep( char*, StrPair* endTag );
virtual XMLNode* ShallowClone( XMLDocument* document ) const;
virtual bool ShallowEqual( const XMLNode* compare ) const;
protected:
- XMLUnknown( XMLDocument* doc );
+ explicit XMLUnknown( XMLDocument* doc );
virtual ~XMLUnknown();
+
+ char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
+
+private:
XMLUnknown( const XMLUnknown& ); // not supported
XMLUnknown& operator=( const XMLUnknown& ); // not supported
};
@@ -1041,6 +1138,9 @@ public:
/// The value of the attribute.
const char* Value() const;
+ /// Gets the line number the attribute is in, if the document was parsed from a file.
+ int GetLineNum() const { return _parseLineNum; }
+
/// The next attribute in the list.
const XMLAttribute* Next() const {
return _next;
@@ -1050,11 +1150,18 @@ public:
If the value isn't an integer, 0 will be returned. There is no error checking;
use QueryIntValue() if you need error checking.
*/
- int IntValue() const {
- int i=0;
- QueryIntValue( &i );
- return i;
- }
+ int IntValue() const {
+ int i = 0;
+ QueryIntValue(&i);
+ return i;
+ }
+
+ int64_t Int64Value() const {
+ int64_t i = 0;
+ QueryInt64Value(&i);
+ return i;
+ }
+
/// Query as an unsigned integer. See IntValue()
unsigned UnsignedValue() const {
unsigned i=0;
@@ -1081,13 +1188,15 @@ public:
}
/** QueryIntValue interprets the attribute as an integer, and returns the value
- in the provided parameter. The function will return XML_NO_ERROR on success,
+ in the provided parameter. The function will return XML_SUCCESS on success,
and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
*/
XMLError QueryIntValue( int* value ) const;
/// See QueryIntValue
XMLError QueryUnsignedValue( unsigned int* value ) const;
- /// See QueryIntValue
+ /// See QueryIntValue
+ XMLError QueryInt64Value(int64_t* value) const;
+ /// See QueryIntValue
XMLError QueryBoolValue( bool* value ) const;
/// See QueryIntValue
XMLError QueryDoubleValue( double* value ) const;
@@ -1100,7 +1209,9 @@ public:
void SetAttribute( int value );
/// Set the attribute to value.
void SetAttribute( unsigned value );
- /// Set the attribute to value.
+ /// Set the attribute to value.
+ void SetAttribute(int64_t value);
+ /// Set the attribute to value.
void SetAttribute( bool value );
/// Set the attribute to value.
void SetAttribute( double value );
@@ -1110,17 +1221,18 @@ public:
private:
enum { BUF_SIZE = 200 };
- XMLAttribute() : _next( 0 ), _memPool( 0 ) {}
+ XMLAttribute() : _name(), _value(),_parseLineNum( 0 ), _next( 0 ), _memPool( 0 ) {}
virtual ~XMLAttribute() {}
XMLAttribute( const XMLAttribute& ); // not supported
void operator=( const XMLAttribute& ); // not supported
void SetName( const char* name );
- char* ParseDeep( char* p, bool processEntities );
+ char* ParseDeep( char* p, bool processEntities, int* curLineNumPtr );
mutable StrPair _name;
mutable StrPair _value;
+ int _parseLineNum;
XMLAttribute* _next;
MemPool* _memPool;
};
@@ -1132,7 +1244,6 @@ private:
*/
class TINYXML2_LIB XMLElement : public XMLNode
{
- friend class XMLBase;
friend class XMLDocument;
public:
/// Get the name of an element (which is the Value() of the node.)
@@ -1178,42 +1289,25 @@ public:
const char* Attribute( const char* name, const char* value=0 ) const;
/** Given an attribute name, IntAttribute() returns the value
- of the attribute interpreted as an integer. 0 will be
- returned if there is an error. For a method with error
- checking, see QueryIntAttribute()
+ of the attribute interpreted as an integer. The default
+ value will be returned if the attribute isn't present,
+ or if there is an error. (For a method with error
+ checking, see QueryIntAttribute()).
*/
- int IntAttribute( const char* name ) const {
- int i=0;
- QueryIntAttribute( name, &i );
- return i;
- }
- /// See IntAttribute()
- unsigned UnsignedAttribute( const char* name ) const {
- unsigned i=0;
- QueryUnsignedAttribute( name, &i );
- return i;
- }
+ int IntAttribute(const char* name, int defaultValue = 0) const;
/// See IntAttribute()
- bool BoolAttribute( const char* name ) const {
- bool b=false;
- QueryBoolAttribute( name, &b );
- return b;
- }
+ unsigned UnsignedAttribute(const char* name, unsigned defaultValue = 0) const;
+ /// See IntAttribute()
+ int64_t Int64Attribute(const char* name, int64_t defaultValue = 0) const;
+ /// See IntAttribute()
+ bool BoolAttribute(const char* name, bool defaultValue = false) const;
/// See IntAttribute()
- double DoubleAttribute( const char* name ) const {
- double d=0;
- QueryDoubleAttribute( name, &d );
- return d;
- }
+ double DoubleAttribute(const char* name, double defaultValue = 0) const;
/// See IntAttribute()
- float FloatAttribute( const char* name ) const {
- float f=0;
- QueryFloatAttribute( name, &f );
- return f;
- }
+ float FloatAttribute(const char* name, float defaultValue = 0) const;
/** Given an attribute name, QueryIntAttribute() returns
- XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
+ XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
can't be performed, or XML_NO_ATTRIBUTE if the attribute
doesn't exist. If successful, the result of the conversion
will be written to 'value'. If not successful, nothing will
@@ -1232,7 +1326,8 @@ public:
}
return a->QueryIntValue( value );
}
- /// See QueryIntAttribute()
+
+ /// See QueryIntAttribute()
XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
const XMLAttribute* a = FindAttribute( name );
if ( !a ) {
@@ -1240,7 +1335,17 @@ public:
}
return a->QueryUnsignedValue( value );
}
- /// See QueryIntAttribute()
+
+ /// See QueryIntAttribute()
+ XMLError QueryInt64Attribute(const char* name, int64_t* value) const {
+ const XMLAttribute* a = FindAttribute(name);
+ if (!a) {
+ return XML_NO_ATTRIBUTE;
+ }
+ return a->QueryInt64Value(value);
+ }
+
+ /// See QueryIntAttribute()
XMLError QueryBoolAttribute( const char* name, bool* value ) const {
const XMLAttribute* a = FindAttribute( name );
if ( !a ) {
@@ -1265,14 +1370,25 @@ public:
return a->QueryFloatValue( value );
}
-
+ /// See QueryIntAttribute()
+ XMLError QueryStringAttribute(const char* name, const char** value) const {
+ const XMLAttribute* a = FindAttribute(name);
+ if (!a) {
+ return XML_NO_ATTRIBUTE;
+ }
+ *value = a->Value();
+ return XML_SUCCESS;
+ }
+
+
+
/** Given an attribute name, QueryAttribute() returns
- XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
+ XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
can't be performed, or XML_NO_ATTRIBUTE if the attribute
doesn't exist. It is overloaded for the primitive types,
and is a generally more convenient replacement of
QueryIntAttribute() and related functions.
-
+
If successful, the result of the conversion
will be written to 'value'. If not successful, nothing will
be written to 'value'. This allows you to provide default
@@ -1283,23 +1399,27 @@ public:
QueryAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
@endverbatim
*/
- int QueryAttribute( const char* name, int* value ) const {
+ XMLError QueryAttribute( const char* name, int* value ) const {
return QueryIntAttribute( name, value );
}
- int QueryAttribute( const char* name, unsigned int* value ) const {
+ XMLError QueryAttribute( const char* name, unsigned int* value ) const {
return QueryUnsignedAttribute( name, value );
}
- int QueryAttribute( const char* name, bool* value ) const {
+ XMLError QueryAttribute(const char* name, int64_t* value) const {
+ return QueryInt64Attribute(name, value);
+ }
+
+ XMLError QueryAttribute( const char* name, bool* value ) const {
return QueryBoolAttribute( name, value );
}
- int QueryAttribute( const char* name, double* value ) const {
+ XMLError QueryAttribute( const char* name, double* value ) const {
return QueryDoubleAttribute( name, value );
}
- int QueryAttribute( const char* name, float* value ) const {
+ XMLError QueryAttribute( const char* name, float* value ) const {
return QueryFloatAttribute( name, value );
}
@@ -1318,7 +1438,14 @@ public:
XMLAttribute* a = FindOrCreateAttribute( name );
a->SetAttribute( value );
}
- /// Sets the named attribute to value.
+
+ /// Sets the named attribute to value.
+ void SetAttribute(const char* name, int64_t value) {
+ XMLAttribute* a = FindOrCreateAttribute(name);
+ a->SetAttribute(value);
+ }
+
+ /// Sets the named attribute to value.
void SetAttribute( const char* name, bool value ) {
XMLAttribute* a = FindOrCreateAttribute( name );
a->SetAttribute( value );
@@ -1400,7 +1527,7 @@ public:
@verbatim
<foo>Hullaballoo!<b>This is text</b></foo>
@endverbatim
-
+
For this XML:
@verbatim
<foo />
@@ -1411,16 +1538,18 @@ public:
@endverbatim
*/
void SetText( const char* inText );
- /// Convenience method for setting text inside and element. See SetText() for important limitations.
+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
void SetText( int value );
- /// Convenience method for setting text inside and element. See SetText() for important limitations.
- void SetText( unsigned value );
- /// Convenience method for setting text inside and element. See SetText() for important limitations.
- void SetText( bool value );
- /// Convenience method for setting text inside and element. See SetText() for important limitations.
- void SetText( double value );
- /// Convenience method for setting text inside and element. See SetText() for important limitations.
- void SetText( float value );
+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
+ void SetText( unsigned value );
+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
+ void SetText(int64_t value);
+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
+ void SetText( bool value );
+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
+ void SetText( double value );
+ /// Convenience method for setting text inside an element. See SetText() for important limitations.
+ void SetText( float value );
/**
Convenience method to query the value of a child text node. This is probably best
@@ -1451,40 +1580,56 @@ public:
XMLError QueryIntText( int* ival ) const;
/// See QueryIntText()
XMLError QueryUnsignedText( unsigned* uval ) const;
- /// See QueryIntText()
+ /// See QueryIntText()
+ XMLError QueryInt64Text(int64_t* uval) const;
+ /// See QueryIntText()
XMLError QueryBoolText( bool* bval ) const;
/// See QueryIntText()
XMLError QueryDoubleText( double* dval ) const;
/// See QueryIntText()
XMLError QueryFloatText( float* fval ) const;
+ int IntText(int defaultValue = 0) const;
+
+ /// See QueryIntText()
+ unsigned UnsignedText(unsigned defaultValue = 0) const;
+ /// See QueryIntText()
+ int64_t Int64Text(int64_t defaultValue = 0) const;
+ /// See QueryIntText()
+ bool BoolText(bool defaultValue = false) const;
+ /// See QueryIntText()
+ double DoubleText(double defaultValue = 0) const;
+ /// See QueryIntText()
+ float FloatText(float defaultValue = 0) const;
+
// internal:
- enum {
+ enum ElementClosingType {
OPEN, // <foo>
CLOSED, // <foo/>
CLOSING // </foo>
};
- int ClosingType() const {
+ ElementClosingType ClosingType() const {
return _closingType;
}
- char* ParseDeep( char* p, StrPair* endTag );
virtual XMLNode* ShallowClone( XMLDocument* document ) const;
virtual bool ShallowEqual( const XMLNode* compare ) const;
+protected:
+ char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
+
private:
XMLElement( XMLDocument* doc );
virtual ~XMLElement();
XMLElement( const XMLElement& ); // not supported
void operator=( const XMLElement& ); // not supported
- XMLAttribute* FindAttribute( const char* name );
XMLAttribute* FindOrCreateAttribute( const char* name );
- //void LinkAttribute( XMLAttribute* attrib );
- char* ParseAttributes( char* p );
+ char* ParseAttributes( char* p, int* curLineNumPtr );
static void DeleteAttribute( XMLAttribute* attribute );
+ XMLAttribute* CreateAttribute();
enum { BUF_SIZE = 200 };
- int _closingType;
+ ElementClosingType _closingType;
// The attribute list is ordered; there is no 'lastAttribute'
// because the list needs to be scanned for dupes before adding
// a new attribute.
@@ -1506,21 +1651,30 @@ enum Whitespace {
class TINYXML2_LIB XMLDocument : public XMLNode
{
friend class XMLElement;
+ // Gives access to SetError and Push/PopDepth, but over-access for everything else.
+ // Wishing C++ had "internal" scope.
+ friend class XMLNode;
+ friend class XMLText;
+ friend class XMLComment;
+ friend class XMLDeclaration;
+ friend class XMLUnknown;
public:
/// constructor
- XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
+ XMLDocument( bool processEntities = true, Whitespace whitespaceMode = PRESERVE_WHITESPACE );
~XMLDocument();
virtual XMLDocument* ToDocument() {
+ TIXMLASSERT( this == _document );
return this;
}
virtual const XMLDocument* ToDocument() const {
+ TIXMLASSERT( this == _document );
return this;
}
/**
Parse an XML file from a character string.
- Returns XML_NO_ERROR (0) on success, or
+ Returns XML_SUCCESS (0) on success, or
an errorID.
You may optionally pass in the 'nBytes', which is
@@ -1532,7 +1686,7 @@ public:
/**
Load an XML file from disk.
- Returns XML_NO_ERROR (0) on success, or
+ Returns XML_SUCCESS (0) on success, or
an errorID.
*/
XMLError LoadFile( const char* filename );
@@ -1541,14 +1695,18 @@ public:
Load an XML file from disk. You are responsible
for providing and closing the FILE*.
- Returns XML_NO_ERROR (0) on success, or
+ NOTE: The file should be opened as binary ("rb")
+ not text in order for TinyXML-2 to correctly
+ do newline normalization.
+
+ Returns XML_SUCCESS (0) on success, or
an errorID.
*/
XMLError LoadFile( FILE* );
/**
Save the XML file to disk.
- Returns XML_NO_ERROR (0) on success, or
+ Returns XML_SUCCESS (0) on success, or
an errorID.
*/
XMLError SaveFile( const char* filename, bool compact = false );
@@ -1557,7 +1715,7 @@ public:
Save the XML file to disk. You are responsible
for providing and closing the FILE*.
- Returns XML_NO_ERROR (0) on success, or
+ Returns XML_SUCCESS (0) on success, or
an errorID.
*/
XMLError SaveFile( FILE* fp, bool compact = false );
@@ -1566,7 +1724,7 @@ public:
return _processEntities;
}
Whitespace WhitespaceMode() const {
- return _whitespace;
+ return _whitespaceMode;
}
/**
@@ -1649,39 +1807,55 @@ public:
Delete a node associated with this document.
It will be unlinked from the DOM.
*/
- void DeleteNode( XMLNode* node ) {
- node->_parent->DeleteChild( node );
- }
+ void DeleteNode( XMLNode* node );
- void SetError( XMLError error, const char* str1, const char* str2 );
+ void ClearError() {
+ SetError(XML_SUCCESS, 0, 0);
+ }
/// Return true if there was an error parsing the document.
bool Error() const {
- return _errorID != XML_NO_ERROR;
+ return _errorID != XML_SUCCESS;
}
/// Return the errorID.
XMLError ErrorID() const {
return _errorID;
}
const char* ErrorName() const;
+ static const char* ErrorIDToName(XMLError errorID);
- /// Return a possibly helpful diagnostic location or string.
- const char* GetErrorStr1() const {
- return _errorStr1;
- }
- /// Return a possibly helpful secondary diagnostic location or string.
- const char* GetErrorStr2() const {
- return _errorStr2;
- }
- /// If there is an error, print it to stdout.
+ /** Returns a "long form" error description. A hopefully helpful
+ diagnostic with location, line number, and/or additional info.
+ */
+ const char* ErrorStr() const;
+
+ /// A (trivial) utility function that prints the ErrorStr() to stdout.
void PrintError() const;
-
+
+ /// Return the line where the error occurred, or zero if unknown.
+ int ErrorLineNum() const
+ {
+ return _errorLineNum;
+ }
+
/// Clear the document, resetting it to the initial state.
void Clear();
- // internal
+ /**
+ Copies this document to a target document.
+ The target will be completely cleared before the copy.
+ If you want to copy a sub-tree, see XMLNode::DeepClone().
+
+ NOTE: that the 'target' must be non-null.
+ */
+ void DeepCopy(XMLDocument* target) const;
+
+ // internal
char* Identify( char* p, XMLNode** node );
+ // internal
+ void MarkInUse(XMLNode*);
+
virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const {
return 0;
}
@@ -1693,13 +1867,22 @@ private:
XMLDocument( const XMLDocument& ); // not supported
void operator=( const XMLDocument& ); // not supported
- bool _writeBOM;
- bool _processEntities;
- XMLError _errorID;
- Whitespace _whitespace;
- const char* _errorStr1;
- const char* _errorStr2;
- char* _charBuffer;
+ bool _writeBOM;
+ bool _processEntities;
+ XMLError _errorID;
+ Whitespace _whitespaceMode;
+ mutable StrPair _errorStr;
+ int _errorLineNum;
+ char* _charBuffer;
+ int _parseCurLineNum;
+ int _parsingDepth;
+ // Memory tracking does add some overhead.
+ // However, the code assumes that you don't
+ // have a bunch of unlinked nodes around.
+ // Therefore it takes less memory to track
+ // in the document vs. a linked list in the XMLNode,
+ // and the performance is the same.
+ DynArray<XMLNode*, 10> _unlinked;
MemPoolT< sizeof(XMLElement) > _elementPool;
MemPoolT< sizeof(XMLAttribute) > _attributePool;
@@ -1707,8 +1890,45 @@ private:
MemPoolT< sizeof(XMLComment) > _commentPool;
static const char* _errorNames[XML_ERROR_COUNT];
+
+ void Parse();
+
+ void SetError( XMLError error, int lineNum, const char* format, ... );
+
+ // Something of an obvious security hole, once it was discovered.
+ // Either an ill-formed XML or an excessively deep one can overflow
+ // the stack. Track stack depth, and error out if needed.
+ class DepthTracker {
+ public:
+ explicit DepthTracker(XMLDocument * document) {
+ this->_document = document;
+ document->PushDepth();
+ }
+ ~DepthTracker() {
+ _document->PopDepth();
+ }
+ private:
+ XMLDocument * _document;
+ };
+ void PushDepth();
+ void PopDepth();
+
+ template<class NodeType, int PoolElementSize>
+ NodeType* CreateUnlinkedNode( MemPoolT<PoolElementSize>& pool );
};
+template<class NodeType, int PoolElementSize>
+inline NodeType* XMLDocument::CreateUnlinkedNode( MemPoolT<PoolElementSize>& pool )
+{
+ TIXMLASSERT( sizeof( NodeType ) == PoolElementSize );
+ TIXMLASSERT( sizeof( NodeType ) == pool.ItemSize() );
+ NodeType* returnNode = new (pool.Alloc()) NodeType( this );
+ TIXMLASSERT( returnNode );
+ returnNode->_memPool = &pool;
+
+ _unlinked.Push(returnNode);
+ return returnNode;
+}
/**
A XMLHandle is a class that wraps a node pointer with null checks; this is
@@ -1750,7 +1970,7 @@ private:
@verbatim
XMLHandle docHandle( &document );
- XMLElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild().NextSibling().ToElement();
+ XMLElement* child2 = docHandle.FirstChildElement( "Document" ).FirstChildElement( "Element" ).FirstChildElement().NextSiblingElement();
if ( child2 )
{
// do something useful
@@ -1769,16 +1989,13 @@ class TINYXML2_LIB XMLHandle
{
public:
/// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
- XMLHandle( XMLNode* node ) {
- _node = node;
+ explicit XMLHandle( XMLNode* node ) : _node( node ) {
}
/// Create a handle from a node.
- XMLHandle( XMLNode& node ) {
- _node = &node;
+ explicit XMLHandle( XMLNode& node ) : _node( &node ) {
}
/// Copy constructor
- XMLHandle( const XMLHandle& ref ) {
- _node = ref._node;
+ XMLHandle( const XMLHandle& ref ) : _node( ref._node ) {
}
/// Assignment
XMLHandle& operator=( const XMLHandle& ref ) {
@@ -1791,32 +2008,32 @@ public:
return XMLHandle( _node ? _node->FirstChild() : 0 );
}
/// Get the first child element of this handle.
- XMLHandle FirstChildElement( const char* value=0 ) {
- return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
+ XMLHandle FirstChildElement( const char* name = 0 ) {
+ return XMLHandle( _node ? _node->FirstChildElement( name ) : 0 );
}
/// Get the last child of this handle.
XMLHandle LastChild() {
return XMLHandle( _node ? _node->LastChild() : 0 );
}
/// Get the last child element of this handle.
- XMLHandle LastChildElement( const char* _value=0 ) {
- return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
+ XMLHandle LastChildElement( const char* name = 0 ) {
+ return XMLHandle( _node ? _node->LastChildElement( name ) : 0 );
}
/// Get the previous sibling of this handle.
XMLHandle PreviousSibling() {
return XMLHandle( _node ? _node->PreviousSibling() : 0 );
}
/// Get the previous sibling element of this handle.
- XMLHandle PreviousSiblingElement( const char* _value=0 ) {
- return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
+ XMLHandle PreviousSiblingElement( const char* name = 0 ) {
+ return XMLHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
}
/// Get the next sibling of this handle.
XMLHandle NextSibling() {
return XMLHandle( _node ? _node->NextSibling() : 0 );
}
/// Get the next sibling element of this handle.
- XMLHandle NextSiblingElement( const char* _value=0 ) {
- return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
+ XMLHandle NextSiblingElement( const char* name = 0 ) {
+ return XMLHandle( _node ? _node->NextSiblingElement( name ) : 0 );
}
/// Safe cast to XMLNode. This can return null.
@@ -1825,19 +2042,19 @@ public:
}
/// Safe cast to XMLElement. This can return null.
XMLElement* ToElement() {
- return ( ( _node == 0 ) ? 0 : _node->ToElement() );
+ return ( _node ? _node->ToElement() : 0 );
}
/// Safe cast to XMLText. This can return null.
XMLText* ToText() {
- return ( ( _node == 0 ) ? 0 : _node->ToText() );
+ return ( _node ? _node->ToText() : 0 );
}
/// Safe cast to XMLUnknown. This can return null.
XMLUnknown* ToUnknown() {
- return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
+ return ( _node ? _node->ToUnknown() : 0 );
}
/// Safe cast to XMLDeclaration. This can return null.
XMLDeclaration* ToDeclaration() {
- return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
+ return ( _node ? _node->ToDeclaration() : 0 );
}
private:
@@ -1852,14 +2069,11 @@ private:
class TINYXML2_LIB XMLConstHandle
{
public:
- XMLConstHandle( const XMLNode* node ) {
- _node = node;
+ explicit XMLConstHandle( const XMLNode* node ) : _node( node ) {
}
- XMLConstHandle( const XMLNode& node ) {
- _node = &node;
+ explicit XMLConstHandle( const XMLNode& node ) : _node( &node ) {
}
- XMLConstHandle( const XMLConstHandle& ref ) {
- _node = ref._node;
+ XMLConstHandle( const XMLConstHandle& ref ) : _node( ref._node ) {
}
XMLConstHandle& operator=( const XMLConstHandle& ref ) {
@@ -1870,26 +2084,26 @@ public:
const XMLConstHandle FirstChild() const {
return XMLConstHandle( _node ? _node->FirstChild() : 0 );
}
- const XMLConstHandle FirstChildElement( const char* value=0 ) const {
- return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
+ const XMLConstHandle FirstChildElement( const char* name = 0 ) const {
+ return XMLConstHandle( _node ? _node->FirstChildElement( name ) : 0 );
}
const XMLConstHandle LastChild() const {
return XMLConstHandle( _node ? _node->LastChild() : 0 );
}
- const XMLConstHandle LastChildElement( const char* _value=0 ) const {
- return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
+ const XMLConstHandle LastChildElement( const char* name = 0 ) const {
+ return XMLConstHandle( _node ? _node->LastChildElement( name ) : 0 );
}
const XMLConstHandle PreviousSibling() const {
return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
}
- const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const {
- return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
+ const XMLConstHandle PreviousSiblingElement( const char* name = 0 ) const {
+ return XMLConstHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
}
const XMLConstHandle NextSibling() const {
return XMLConstHandle( _node ? _node->NextSibling() : 0 );
}
- const XMLConstHandle NextSiblingElement( const char* _value=0 ) const {
- return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
+ const XMLConstHandle NextSiblingElement( const char* name = 0 ) const {
+ return XMLConstHandle( _node ? _node->NextSiblingElement( name ) : 0 );
}
@@ -1897,16 +2111,16 @@ public:
return _node;
}
const XMLElement* ToElement() const {
- return ( ( _node == 0 ) ? 0 : _node->ToElement() );
+ return ( _node ? _node->ToElement() : 0 );
}
const XMLText* ToText() const {
- return ( ( _node == 0 ) ? 0 : _node->ToText() );
+ return ( _node ? _node->ToText() : 0 );
}
const XMLUnknown* ToUnknown() const {
- return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
+ return ( _node ? _node->ToUnknown() : 0 );
}
const XMLDeclaration* ToDeclaration() const {
- return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
+ return ( _node ? _node->ToDeclaration() : 0 );
}
private:
@@ -1978,7 +2192,8 @@ public:
void PushAttribute( const char* name, const char* value );
void PushAttribute( const char* name, int value );
void PushAttribute( const char* name, unsigned value );
- void PushAttribute( const char* name, bool value );
+ void PushAttribute(const char* name, int64_t value);
+ void PushAttribute( const char* name, bool value );
void PushAttribute( const char* name, double value );
/// If streaming, close the Element.
virtual void CloseElement( bool compactMode=false );
@@ -1989,7 +2204,9 @@ public:
void PushText( int value );
/// Add a text node from an unsigned.
void PushText( unsigned value );
- /// Add a text node from a bool.
+ /// Add a text node from an unsigned.
+ void PushText(int64_t value);
+ /// Add a text node from a bool.
void PushText( bool value );
/// Add a text node from a float.
void PushText( float value );
@@ -2037,6 +2254,7 @@ public:
void ClearBuffer() {
_buffer.Clear();
_buffer.Push(0);
+ _firstElement = true;
}
protected:
@@ -2047,8 +2265,11 @@ protected:
*/
virtual void PrintSpace( int depth );
void Print( const char* format, ... );
+ void Write( const char* data, size_t size );
+ inline void Write( const char* data ) { Write( data, strlen( data ) ); }
+ void Putc( char ch );
- void SealElement();
+ void SealElementIfJustOpened();
bool _elementJustOpened;
DynArray< const char*, 10 > _stack;
@@ -2070,6 +2291,10 @@ private:
bool _restrictedEntityFlag[ENTITY_RANGE];
DynArray< char, 20 > _buffer;
+
+ // Prohibit cloning, intentionally not implemented
+ XMLPrinter( const XMLPrinter& );
+ XMLPrinter& operator=( const XMLPrinter& );
};
-----------------------------------------------------------------------
Summary of changes:
tests/xmltester/tinyxml2/tinyxml2.cpp | 1403 +++++++++++++++++++++++----------
tests/xmltester/tinyxml2/tinyxml2.h | 805 ++++++++++++-------
2 files changed, 1513 insertions(+), 695 deletions(-)
hooks/post-receive
--
GEOS
More information about the geos-commits
mailing list