--- /dev/null
+/*\r
+Original code by Lee Thomason (www.grinninglizard.com)\r
+\r
+This software is provided 'as-is', without any express or implied\r
+warranty. In no event will the authors be held liable for any\r
+damages arising from the use of this software.\r
+\r
+Permission is granted to anyone to use this software for any\r
+purpose, including commercial applications, and to alter it and\r
+redistribute it freely, subject to the following restrictions:\r
+\r
+1. The origin of this software must not be misrepresented; you must\r
+not claim that you wrote the original software. If you use this\r
+software in a product, an acknowledgment in the product documentation\r
+would be appreciated but is not required.\r
+\r
+2. Altered source versions must be plainly marked as such, and\r
+must not be misrepresented as being the original software.\r
+\r
+3. This notice may not be removed or altered from any source\r
+distribution.\r
+*/\r
+\r
+#include "tinyxml2.h"\r
+\r
+#include <new> // yes, this one new style header, is in the Android SDK.\r
+#if defined(ANDROID_NDK) || defined(__QNXNTO__)\r
+# include <stddef.h>\r
+# include <stdarg.h>\r
+#else\r
+# include <cstddef>\r
+# include <cstdarg>\r
+#endif\r
+\r
+#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)\r
+ // Microsoft Visual Studio, version 2005 and higher. Not WinCE.\r
+ /*int _snprintf_s(\r
+ char *buffer,\r
+ size_t sizeOfBuffer,\r
+ size_t count,\r
+ const char *format [,\r
+ argument] ...\r
+ );*/\r
+ static inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )\r
+ {\r
+ va_list va;\r
+ va_start( va, format );\r
+ int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );\r
+ va_end( va );\r
+ return result;\r
+ }\r
+\r
+ static inline int TIXML_VSNPRINTF( char* buffer, size_t size, const char* format, va_list va )\r
+ {\r
+ int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );\r
+ return result;\r
+ }\r
+\r
+ #define TIXML_VSCPRINTF _vscprintf\r
+ #define TIXML_SSCANF sscanf_s\r
+#elif defined _MSC_VER\r
+ // Microsoft Visual Studio 2003 and earlier or WinCE\r
+ #define TIXML_SNPRINTF _snprintf\r
+ #define TIXML_VSNPRINTF _vsnprintf\r
+ #define TIXML_SSCANF sscanf\r
+ #if (_MSC_VER < 1400 ) && (!defined WINCE)\r
+ // Microsoft Visual Studio 2003 and not WinCE.\r
+ #define TIXML_VSCPRINTF _vscprintf // VS2003's C runtime has this, but VC6 C runtime or WinCE SDK doesn't have.\r
+ #else\r
+ // Microsoft Visual Studio 2003 and earlier or WinCE.\r
+ static inline int TIXML_VSCPRINTF( const char* format, va_list va )\r
+ {\r
+ int len = 512;\r
+ for (;;) {\r
+ len = len*2;\r
+ char* str = new char[len]();\r
+ const int required = _vsnprintf(str, len, format, va);\r
+ delete[] str;\r
+ if ( required != -1 ) {\r
+ TIXMLASSERT( required >= 0 );\r
+ len = required;\r
+ break;\r
+ }\r
+ }\r
+ TIXMLASSERT( len >= 0 );\r
+ return len;\r
+ }\r
+ #endif\r
+#else\r
+ // GCC version 3 and higher\r
+ //#warning( "Using sn* functions." )\r
+ #define TIXML_SNPRINTF snprintf\r
+ #define TIXML_VSNPRINTF vsnprintf\r
+ static inline int TIXML_VSCPRINTF( const char* format, va_list va )\r
+ {\r
+ int len = vsnprintf( 0, 0, format, va );\r
+ TIXMLASSERT( len >= 0 );\r
+ return len;\r
+ }\r
+ #define TIXML_SSCANF sscanf\r
+#endif\r
+\r
+\r
+static const char LINE_FEED = (char)0x0a; // all line endings are normalized to LF\r
+static const char LF = LINE_FEED;\r
+static const char CARRIAGE_RETURN = (char)0x0d; // CR gets filtered out\r
+static const char CR = CARRIAGE_RETURN;\r
+static const char SINGLE_QUOTE = '\'';\r
+static const char DOUBLE_QUOTE = '\"';\r
+\r
+// Bunch of unicode info at:\r
+// http://www.unicode.org/faq/utf_bom.html\r
+// ef bb bf (Microsoft "lead bytes") - designates UTF-8\r
+\r
+static const unsigned char TIXML_UTF_LEAD_0 = 0xefU;\r
+static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;\r
+static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;\r
+\r
+namespace tinyxml2\r
+{\r
+\r
+struct Entity {\r
+ const char* pattern;\r
+ int length;\r
+ char value;\r
+};\r
+\r
+static const int NUM_ENTITIES = 5;\r
+static const Entity entities[NUM_ENTITIES] = {\r
+ { "quot", 4, DOUBLE_QUOTE },\r
+ { "amp", 3, '&' },\r
+ { "apos", 4, SINGLE_QUOTE },\r
+ { "lt", 2, '<' },\r
+ { "gt", 2, '>' }\r
+};\r
+\r
+\r
+StrPair::~StrPair()\r
+{\r
+ Reset();\r
+}\r
+\r
+\r
+void StrPair::TransferTo( StrPair* other )\r
+{\r
+ if ( this == other ) {\r
+ return;\r
+ }\r
+ // This in effect implements the assignment operator by "moving"\r
+ // ownership (as in auto_ptr).\r
+\r
+ TIXMLASSERT( other->_flags == 0 );\r
+ TIXMLASSERT( other->_start == 0 );\r
+ TIXMLASSERT( other->_end == 0 );\r
+\r
+ other->Reset();\r
+\r
+ other->_flags = _flags;\r
+ other->_start = _start;\r
+ other->_end = _end;\r
+\r
+ _flags = 0;\r
+ _start = 0;\r
+ _end = 0;\r
+}\r
+\r
+void StrPair::Reset()\r
+{\r
+ if ( _flags & NEEDS_DELETE ) {\r
+ delete [] _start;\r
+ }\r
+ _flags = 0;\r
+ _start = 0;\r
+ _end = 0;\r
+}\r
+\r
+\r
+void StrPair::SetStr( const char* str, int flags )\r
+{\r
+ TIXMLASSERT( str );\r
+ Reset();\r
+ size_t len = strlen( str );\r
+ TIXMLASSERT( _start == 0 );\r
+ _start = new char[ len+1 ];\r
+ memcpy( _start, str, len+1 );\r
+ _end = _start + len;\r
+ _flags = flags | NEEDS_DELETE;\r
+}\r
+\r
+\r
+char* StrPair::ParseText( char* p, const char* endTag, int strFlags )\r
+{\r
+ TIXMLASSERT( endTag && *endTag );\r
+\r
+ char* start = p;\r
+ char endChar = *endTag;\r
+ size_t length = strlen( endTag );\r
+\r
+ // Inner loop of text parsing.\r
+ while ( *p ) {\r
+ if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {\r
+ Set( start, p, strFlags );\r
+ return p + length;\r
+ }\r
+ ++p;\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+char* StrPair::ParseName( char* p )\r
+{\r
+ if ( !p || !(*p) ) {\r
+ return 0;\r
+ }\r
+ if ( !XMLUtil::IsNameStartChar( *p ) ) {\r
+ return 0;\r
+ }\r
+\r
+ char* const start = p;\r
+ ++p;\r
+ while ( *p && XMLUtil::IsNameChar( *p ) ) {\r
+ ++p;\r
+ }\r
+\r
+ Set( start, p, 0 );\r
+ return p;\r
+}\r
+\r
+\r
+void StrPair::CollapseWhitespace()\r
+{\r
+ // Adjusting _start would cause undefined behavior on delete[]\r
+ TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );\r
+ // Trim leading space.\r
+ _start = XMLUtil::SkipWhiteSpace( _start );\r
+\r
+ if ( *_start ) {\r
+ char* p = _start; // the read pointer\r
+ char* q = _start; // the write pointer\r
+\r
+ while( *p ) {\r
+ if ( XMLUtil::IsWhiteSpace( *p )) {\r
+ p = XMLUtil::SkipWhiteSpace( p );\r
+ if ( *p == 0 ) {\r
+ break; // don't write to q; this trims the trailing space.\r
+ }\r
+ *q = ' ';\r
+ ++q;\r
+ }\r
+ *q = *p;\r
+ ++q;\r
+ ++p;\r
+ }\r
+ *q = 0;\r
+ }\r
+}\r
+\r
+\r
+const char* StrPair::GetStr()\r
+{\r
+ TIXMLASSERT( _start );\r
+ TIXMLASSERT( _end );\r
+ if ( _flags & NEEDS_FLUSH ) {\r
+ *_end = 0;\r
+ _flags ^= NEEDS_FLUSH;\r
+\r
+ if ( _flags ) {\r
+ char* p = _start; // the read pointer\r
+ char* q = _start; // the write pointer\r
+\r
+ while( p < _end ) {\r
+ if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {\r
+ // CR-LF pair becomes LF\r
+ // CR alone becomes LF\r
+ // LF-CR becomes LF\r
+ if ( *(p+1) == LF ) {\r
+ p += 2;\r
+ }\r
+ else {\r
+ ++p;\r
+ }\r
+ *q++ = LF;\r
+ }\r
+ else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {\r
+ if ( *(p+1) == CR ) {\r
+ p += 2;\r
+ }\r
+ else {\r
+ ++p;\r
+ }\r
+ *q++ = LF;\r
+ }\r
+ else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {\r
+ // Entities handled by tinyXML2:\r
+ // - special entities in the entity table [in/out]\r
+ // - numeric character reference [in]\r
+ // 中 or 中\r
+\r
+ if ( *(p+1) == '#' ) {\r
+ const int buflen = 10;\r
+ char buf[buflen] = { 0 };\r
+ int len = 0;\r
+ char* adjusted = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );\r
+ if ( adjusted == 0 ) {\r
+ *q = *p;\r
+ ++p;\r
+ ++q;\r
+ }\r
+ else {\r
+ TIXMLASSERT( 0 <= len && len <= buflen );\r
+ TIXMLASSERT( q + len <= adjusted );\r
+ p = adjusted;\r
+ memcpy( q, buf, len );\r
+ q += len;\r
+ }\r
+ }\r
+ else {\r
+ bool entityFound = false;\r
+ for( int i = 0; i < NUM_ENTITIES; ++i ) {\r
+ const Entity& entity = entities[i];\r
+ if ( strncmp( p + 1, entity.pattern, entity.length ) == 0\r
+ && *( p + entity.length + 1 ) == ';' ) {\r
+ // Found an entity - convert.\r
+ *q = entity.value;\r
+ ++q;\r
+ p += entity.length + 2;\r
+ entityFound = true;\r
+ break;\r
+ }\r
+ }\r
+ if ( !entityFound ) {\r
+ // fixme: treat as error?\r
+ ++p;\r
+ ++q;\r
+ }\r
+ }\r
+ }\r
+ else {\r
+ *q = *p;\r
+ ++p;\r
+ ++q;\r
+ }\r
+ }\r
+ *q = 0;\r
+ }\r
+ // The loop below has plenty going on, and this\r
+ // is a less useful mode. Break it out.\r
+ if ( _flags & NEEDS_WHITESPACE_COLLAPSING ) {\r
+ CollapseWhitespace();\r
+ }\r
+ _flags = (_flags & NEEDS_DELETE);\r
+ }\r
+ TIXMLASSERT( _start );\r
+ return _start;\r
+}\r
+\r
+\r
+\r
+\r
+// --------- XMLUtil ----------- //\r
+\r
+const char* XMLUtil::ReadBOM( const char* p, bool* bom )\r
+{\r
+ TIXMLASSERT( p );\r
+ TIXMLASSERT( bom );\r
+ *bom = false;\r
+ const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);\r
+ // Check for BOM:\r
+ if ( *(pu+0) == TIXML_UTF_LEAD_0\r
+ && *(pu+1) == TIXML_UTF_LEAD_1\r
+ && *(pu+2) == TIXML_UTF_LEAD_2 ) {\r
+ *bom = true;\r
+ p += 3;\r
+ }\r
+ TIXMLASSERT( p );\r
+ return p;\r
+}\r
+\r
+\r
+void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )\r
+{\r
+ const unsigned long BYTE_MASK = 0xBF;\r
+ const unsigned long BYTE_MARK = 0x80;\r
+ const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };\r
+\r
+ if (input < 0x80) {\r
+ *length = 1;\r
+ }\r
+ else if ( input < 0x800 ) {\r
+ *length = 2;\r
+ }\r
+ else if ( input < 0x10000 ) {\r
+ *length = 3;\r
+ }\r
+ else if ( input < 0x200000 ) {\r
+ *length = 4;\r
+ }\r
+ else {\r
+ *length = 0; // This code won't convert this correctly anyway.\r
+ return;\r
+ }\r
+\r
+ output += *length;\r
+\r
+ // Scary scary fall throughs.\r
+ switch (*length) {\r
+ case 4:\r
+ --output;\r
+ *output = (char)((input | BYTE_MARK) & BYTE_MASK);\r
+ input >>= 6;\r
+ case 3:\r
+ --output;\r
+ *output = (char)((input | BYTE_MARK) & BYTE_MASK);\r
+ input >>= 6;\r
+ case 2:\r
+ --output;\r
+ *output = (char)((input | BYTE_MARK) & BYTE_MASK);\r
+ input >>= 6;\r
+ case 1:\r
+ --output;\r
+ *output = (char)(input | FIRST_BYTE_MARK[*length]);\r
+ break;\r
+ default:\r
+ TIXMLASSERT( false );\r
+ }\r
+}\r
+\r
+\r
+const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )\r
+{\r
+ // Presume an entity, and pull it out.\r
+ *length = 0;\r
+\r
+ if ( *(p+1) == '#' && *(p+2) ) {\r
+ unsigned long ucs = 0;\r
+ TIXMLASSERT( sizeof( ucs ) >= 4 );\r
+ ptrdiff_t delta = 0;\r
+ unsigned mult = 1;\r
+ static const char SEMICOLON = ';';\r
+\r
+ if ( *(p+2) == 'x' ) {\r
+ // Hexadecimal.\r
+ const char* q = p+3;\r
+ if ( !(*q) ) {\r
+ return 0;\r
+ }\r
+\r
+ q = strchr( q, SEMICOLON );\r
+\r
+ if ( !q ) {\r
+ return 0;\r
+ }\r
+ TIXMLASSERT( *q == SEMICOLON );\r
+\r
+ delta = q-p;\r
+ --q;\r
+\r
+ while ( *q != 'x' ) {\r
+ unsigned int digit = 0;\r
+\r
+ if ( *q >= '0' && *q <= '9' ) {\r
+ digit = *q - '0';\r
+ }\r
+ else if ( *q >= 'a' && *q <= 'f' ) {\r
+ digit = *q - 'a' + 10;\r
+ }\r
+ else if ( *q >= 'A' && *q <= 'F' ) {\r
+ digit = *q - 'A' + 10;\r
+ }\r
+ else {\r
+ return 0;\r
+ }\r
+ TIXMLASSERT( digit >= 0 && digit < 16);\r
+ TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );\r
+ const unsigned int digitScaled = mult * digit;\r
+ TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );\r
+ ucs += digitScaled;\r
+ TIXMLASSERT( mult <= UINT_MAX / 16 );\r
+ mult *= 16;\r
+ --q;\r
+ }\r
+ }\r
+ else {\r
+ // Decimal.\r
+ const char* q = p+2;\r
+ if ( !(*q) ) {\r
+ return 0;\r
+ }\r
+\r
+ q = strchr( q, SEMICOLON );\r
+\r
+ if ( !q ) {\r
+ return 0;\r
+ }\r
+ TIXMLASSERT( *q == SEMICOLON );\r
+\r
+ delta = q-p;\r
+ --q;\r
+\r
+ while ( *q != '#' ) {\r
+ if ( *q >= '0' && *q <= '9' ) {\r
+ const unsigned int digit = *q - '0';\r
+ TIXMLASSERT( digit >= 0 && digit < 10);\r
+ TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );\r
+ const unsigned int digitScaled = mult * digit;\r
+ TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );\r
+ ucs += digitScaled;\r
+ }\r
+ else {\r
+ return 0;\r
+ }\r
+ TIXMLASSERT( mult <= UINT_MAX / 10 );\r
+ mult *= 10;\r
+ --q;\r
+ }\r
+ }\r
+ // convert the UCS to UTF-8\r
+ ConvertUTF32ToUTF8( ucs, value, length );\r
+ return p + delta + 1;\r
+ }\r
+ return p+1;\r
+}\r
+\r
+\r
+void XMLUtil::ToStr( int v, char* buffer, int bufferSize )\r
+{\r
+ TIXML_SNPRINTF( buffer, bufferSize, "%d", v );\r
+}\r
+\r
+\r
+void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )\r
+{\r
+ TIXML_SNPRINTF( buffer, bufferSize, "%u", v );\r
+}\r
+\r
+\r
+void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )\r
+{\r
+ TIXML_SNPRINTF( buffer, bufferSize, "%d", v ? 1 : 0 );\r
+}\r
+\r
+/*\r
+ ToStr() of a number is a very tricky topic.\r
+ https://github.com/leethomason/tinyxml2/issues/106\r
+*/\r
+void XMLUtil::ToStr( float v, char* buffer, int bufferSize )\r
+{\r
+ TIXML_SNPRINTF( buffer, bufferSize, "%.8g", v );\r
+}\r
+\r
+\r
+void XMLUtil::ToStr( double v, char* buffer, int bufferSize )\r
+{\r
+ TIXML_SNPRINTF( buffer, bufferSize, "%.17g", v );\r
+}\r
+\r
+\r
+bool XMLUtil::ToInt( const char* str, int* value )\r
+{\r
+ if ( TIXML_SSCANF( str, "%d", value ) == 1 ) {\r
+ return true;\r
+ }\r
+ return false;\r
+}\r
+\r
+bool XMLUtil::ToUnsigned( const char* str, unsigned *value )\r
+{\r
+ if ( TIXML_SSCANF( str, "%u", value ) == 1 ) {\r
+ return true;\r
+ }\r
+ return false;\r
+}\r
+\r
+bool XMLUtil::ToBool( const char* str, bool* value )\r
+{\r
+ int ival = 0;\r
+ if ( ToInt( str, &ival )) {\r
+ *value = (ival==0) ? false : true;\r
+ return true;\r
+ }\r
+ if ( StringEqual( str, "true" ) ) {\r
+ *value = true;\r
+ return true;\r
+ }\r
+ else if ( StringEqual( str, "false" ) ) {\r
+ *value = false;\r
+ return true;\r
+ }\r
+ return false;\r
+}\r
+\r
+\r
+bool XMLUtil::ToFloat( const char* str, float* value )\r
+{\r
+ if ( TIXML_SSCANF( str, "%f", value ) == 1 ) {\r
+ return true;\r
+ }\r
+ return false;\r
+}\r
+\r
+bool XMLUtil::ToDouble( const char* str, double* value )\r
+{\r
+ if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) {\r
+ return true;\r
+ }\r
+ return false;\r
+}\r
+\r
+\r
+char* XMLDocument::Identify( char* p, XMLNode** node )\r
+{\r
+ TIXMLASSERT( node );\r
+ TIXMLASSERT( p );\r
+ char* const start = p;\r
+ p = XMLUtil::SkipWhiteSpace( p );\r
+ if( !*p ) {\r
+ *node = 0;\r
+ TIXMLASSERT( p );\r
+ return p;\r
+ }\r
+\r
+ // These strings define the matching patterns:\r
+ static const char* xmlHeader = { "<?" };\r
+ static const char* commentHeader = { "<!--" };\r
+ static const char* cdataHeader = { "<![CDATA[" };\r
+ static const char* dtdHeader = { "<!" };\r
+ static const char* elementHeader = { "<" }; // and a header for everything else; check last.\r
+\r
+ static const int xmlHeaderLen = 2;\r
+ static const int commentHeaderLen = 4;\r
+ static const int cdataHeaderLen = 9;\r
+ static const int dtdHeaderLen = 2;\r
+ static const int elementHeaderLen = 1;\r
+\r
+ TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) ); // use same memory pool\r
+ TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) ); // use same memory pool\r
+ XMLNode* returnNode = 0;\r
+ if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {\r
+ TIXMLASSERT( sizeof( XMLDeclaration ) == _commentPool.ItemSize() );\r
+ returnNode = new (_commentPool.Alloc()) XMLDeclaration( this );\r
+ returnNode->_memPool = &_commentPool;\r
+ p += xmlHeaderLen;\r
+ }\r
+ else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {\r
+ TIXMLASSERT( sizeof( XMLComment ) == _commentPool.ItemSize() );\r
+ returnNode = new (_commentPool.Alloc()) XMLComment( this );\r
+ returnNode->_memPool = &_commentPool;\r
+ p += commentHeaderLen;\r
+ }\r
+ else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {\r
+ TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );\r
+ XMLText* text = new (_textPool.Alloc()) XMLText( this );\r
+ returnNode = text;\r
+ returnNode->_memPool = &_textPool;\r
+ p += cdataHeaderLen;\r
+ text->SetCData( true );\r
+ }\r
+ else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {\r
+ TIXMLASSERT( sizeof( XMLUnknown ) == _commentPool.ItemSize() );\r
+ returnNode = new (_commentPool.Alloc()) XMLUnknown( this );\r
+ returnNode->_memPool = &_commentPool;\r
+ p += dtdHeaderLen;\r
+ }\r
+ else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {\r
+ TIXMLASSERT( sizeof( XMLElement ) == _elementPool.ItemSize() );\r
+ returnNode = new (_elementPool.Alloc()) XMLElement( this );\r
+ returnNode->_memPool = &_elementPool;\r
+ p += elementHeaderLen;\r
+ }\r
+ else {\r
+ TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );\r
+ returnNode = new (_textPool.Alloc()) XMLText( this );\r
+ returnNode->_memPool = &_textPool;\r
+ p = start; // Back it up, all the text counts.\r
+ }\r
+\r
+ TIXMLASSERT( returnNode );\r
+ TIXMLASSERT( p );\r
+ *node = returnNode;\r
+ return p;\r
+}\r
+\r
+\r
+bool XMLDocument::Accept( XMLVisitor* visitor ) const\r
+{\r
+ TIXMLASSERT( visitor );\r
+ if ( visitor->VisitEnter( *this ) ) {\r
+ for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {\r
+ if ( !node->Accept( visitor ) ) {\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ return visitor->VisitExit( *this );\r
+}\r
+\r
+\r
+// --------- XMLNode ----------- //\r
+\r
+XMLNode::XMLNode( XMLDocument* doc ) :\r
+ _document( doc ),\r
+ _parent( 0 ),\r
+ _firstChild( 0 ), _lastChild( 0 ),\r
+ _prev( 0 ), _next( 0 ),\r
+ _memPool( 0 )\r
+{\r
+}\r
+\r
+\r
+XMLNode::~XMLNode()\r
+{\r
+ DeleteChildren();\r
+ if ( _parent ) {\r
+ _parent->Unlink( this );\r
+ }\r
+}\r
+\r
+const char* XMLNode::Value() const \r
+{\r
+ // Catch an edge case: XMLDocuments don't have a a Value. Carefully return nullptr.\r
+ if ( this->ToDocument() )\r
+ return 0;\r
+ return _value.GetStr();\r
+}\r
+\r
+void XMLNode::SetValue( const char* str, bool staticMem )\r
+{\r
+ if ( staticMem ) {\r
+ _value.SetInternedStr( str );\r
+ }\r
+ else {\r
+ _value.SetStr( str );\r
+ }\r
+}\r
+\r
+\r
+void XMLNode::DeleteChildren()\r
+{\r
+ while( _firstChild ) {\r
+ TIXMLASSERT( _lastChild );\r
+ TIXMLASSERT( _firstChild->_document == _document );\r
+ XMLNode* node = _firstChild;\r
+ Unlink( node );\r
+\r
+ DeleteNode( node );\r
+ }\r
+ _firstChild = _lastChild = 0;\r
+}\r
+\r
+\r
+void XMLNode::Unlink( XMLNode* child )\r
+{\r
+ TIXMLASSERT( child );\r
+ TIXMLASSERT( child->_document == _document );\r
+ TIXMLASSERT( child->_parent == this );\r
+ if ( child == _firstChild ) {\r
+ _firstChild = _firstChild->_next;\r
+ }\r
+ if ( child == _lastChild ) {\r
+ _lastChild = _lastChild->_prev;\r
+ }\r
+\r
+ if ( child->_prev ) {\r
+ child->_prev->_next = child->_next;\r
+ }\r
+ if ( child->_next ) {\r
+ child->_next->_prev = child->_prev;\r
+ }\r
+ child->_parent = 0;\r
+}\r
+\r
+\r
+void XMLNode::DeleteChild( XMLNode* node )\r
+{\r
+ TIXMLASSERT( node );\r
+ TIXMLASSERT( node->_document == _document );\r
+ TIXMLASSERT( node->_parent == this );\r
+ Unlink( node );\r
+ DeleteNode( node );\r
+}\r
+\r
+\r
+XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )\r
+{\r
+ TIXMLASSERT( addThis );\r
+ if ( addThis->_document != _document ) {\r
+ TIXMLASSERT( false );\r
+ return 0;\r
+ }\r
+ InsertChildPreamble( addThis );\r
+\r
+ if ( _lastChild ) {\r
+ TIXMLASSERT( _firstChild );\r
+ TIXMLASSERT( _lastChild->_next == 0 );\r
+ _lastChild->_next = addThis;\r
+ addThis->_prev = _lastChild;\r
+ _lastChild = addThis;\r
+\r
+ addThis->_next = 0;\r
+ }\r
+ else {\r
+ TIXMLASSERT( _firstChild == 0 );\r
+ _firstChild = _lastChild = addThis;\r
+\r
+ addThis->_prev = 0;\r
+ addThis->_next = 0;\r
+ }\r
+ addThis->_parent = this;\r
+ return addThis;\r
+}\r
+\r
+\r
+XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )\r
+{\r
+ TIXMLASSERT( addThis );\r
+ if ( addThis->_document != _document ) {\r
+ TIXMLASSERT( false );\r
+ return 0;\r
+ }\r
+ InsertChildPreamble( addThis );\r
+\r
+ if ( _firstChild ) {\r
+ TIXMLASSERT( _lastChild );\r
+ TIXMLASSERT( _firstChild->_prev == 0 );\r
+\r
+ _firstChild->_prev = addThis;\r
+ addThis->_next = _firstChild;\r
+ _firstChild = addThis;\r
+\r
+ addThis->_prev = 0;\r
+ }\r
+ else {\r
+ TIXMLASSERT( _lastChild == 0 );\r
+ _firstChild = _lastChild = addThis;\r
+\r
+ addThis->_prev = 0;\r
+ addThis->_next = 0;\r
+ }\r
+ addThis->_parent = this;\r
+ return addThis;\r
+}\r
+\r
+\r
+XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )\r
+{\r
+ TIXMLASSERT( addThis );\r
+ if ( addThis->_document != _document ) {\r
+ TIXMLASSERT( false );\r
+ return 0;\r
+ }\r
+\r
+ TIXMLASSERT( afterThis );\r
+\r
+ if ( afterThis->_parent != this ) {\r
+ TIXMLASSERT( false );\r
+ return 0;\r
+ }\r
+\r
+ if ( afterThis->_next == 0 ) {\r
+ // The last node or the only node.\r
+ return InsertEndChild( addThis );\r
+ }\r
+ InsertChildPreamble( addThis );\r
+ addThis->_prev = afterThis;\r
+ addThis->_next = afterThis->_next;\r
+ afterThis->_next->_prev = addThis;\r
+ afterThis->_next = addThis;\r
+ addThis->_parent = this;\r
+ return addThis;\r
+}\r
+\r
+\r
+\r
+\r
+const XMLElement* XMLNode::FirstChildElement( const char* name ) const\r
+{\r
+ for( const XMLNode* node = _firstChild; node; node = node->_next ) {\r
+ const XMLElement* element = node->ToElement();\r
+ if ( element ) {\r
+ if ( !name || XMLUtil::StringEqual( element->Name(), name ) ) {\r
+ return element;\r
+ }\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+const XMLElement* XMLNode::LastChildElement( const char* name ) const\r
+{\r
+ for( const XMLNode* node = _lastChild; node; node = node->_prev ) {\r
+ const XMLElement* element = node->ToElement();\r
+ if ( element ) {\r
+ if ( !name || XMLUtil::StringEqual( element->Name(), name ) ) {\r
+ return element;\r
+ }\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+const XMLElement* XMLNode::NextSiblingElement( const char* name ) const\r
+{\r
+ for( const XMLNode* node = _next; node; node = node->_next ) {\r
+ const XMLElement* element = node->ToElement();\r
+ if ( element\r
+ && (!name || XMLUtil::StringEqual( name, element->Name() ))) {\r
+ return element;\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const\r
+{\r
+ for( const XMLNode* node = _prev; node; node = node->_prev ) {\r
+ const XMLElement* element = node->ToElement();\r
+ if ( element\r
+ && (!name || XMLUtil::StringEqual( name, element->Name() ))) {\r
+ return element;\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+char* XMLNode::ParseDeep( char* p, StrPair* parentEnd )\r
+{\r
+ // This is a recursive method, but thinking about it "at the current level"\r
+ // it is a pretty simple flat list:\r
+ // <foo/>\r
+ // <!-- comment -->\r
+ //\r
+ // With a special case:\r
+ // <foo>\r
+ // </foo>\r
+ // <!-- comment -->\r
+ //\r
+ // Where the closing element (/foo) *must* be the next thing after the opening\r
+ // element, and the names must match. BUT the tricky bit is that the closing\r
+ // element will be read by the child.\r
+ //\r
+ // 'endTag' is the end tag for this node, it is returned by a call to a child.\r
+ // 'parentEnd' is the end tag for the parent, which is filled in and returned.\r
+\r
+ while( p && *p ) {\r
+ XMLNode* node = 0;\r
+\r
+ p = _document->Identify( p, &node );\r
+ if ( node == 0 ) {\r
+ break;\r
+ }\r
+\r
+ StrPair endTag;\r
+ p = node->ParseDeep( p, &endTag );\r
+ if ( !p ) {\r
+ DeleteNode( node );\r
+ if ( !_document->Error() ) {\r
+ _document->SetError( XML_ERROR_PARSING, 0, 0 );\r
+ }\r
+ break;\r
+ }\r
+\r
+ XMLDeclaration* decl = node->ToDeclaration();\r
+ if ( decl ) {\r
+ // A declaration can only be the first child of a document.\r
+ // Set error, if document already has children.\r
+ if ( !_document->NoChildren() ) {\r
+ _document->SetError( XML_ERROR_PARSING_DECLARATION, decl->Value(), 0);\r
+ DeleteNode( decl );\r
+ break;\r
+ }\r
+ }\r
+\r
+ XMLElement* ele = node->ToElement();\r
+ if ( ele ) {\r
+ // We read the end tag. Return it to the parent.\r
+ if ( ele->ClosingType() == XMLElement::CLOSING ) {\r
+ if ( parentEnd ) {\r
+ ele->_value.TransferTo( parentEnd );\r
+ }\r
+ node->_memPool->SetTracked(); // created and then immediately deleted.\r
+ DeleteNode( node );\r
+ return p;\r
+ }\r
+\r
+ // Handle an end tag returned to this level.\r
+ // And handle a bunch of annoying errors.\r
+ bool mismatch = false;\r
+ if ( endTag.Empty() ) {\r
+ if ( ele->ClosingType() == XMLElement::OPEN ) {\r
+ mismatch = true;\r
+ }\r
+ }\r
+ else {\r
+ if ( ele->ClosingType() != XMLElement::OPEN ) {\r
+ mismatch = true;\r
+ }\r
+ else if ( !XMLUtil::StringEqual( endTag.GetStr(), ele->Name() ) ) {\r
+ mismatch = true;\r
+ }\r
+ }\r
+ if ( mismatch ) {\r
+ _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, ele->Name(), 0 );\r
+ DeleteNode( node );\r
+ break;\r
+ }\r
+ }\r
+ InsertEndChild( node );\r
+ }\r
+ return 0;\r
+}\r
+\r
+void XMLNode::DeleteNode( XMLNode* node )\r
+{\r
+ if ( node == 0 ) {\r
+ return;\r
+ }\r
+ MemPool* pool = node->_memPool;\r
+ node->~XMLNode();\r
+ pool->Free( node );\r
+}\r
+\r
+void XMLNode::InsertChildPreamble( XMLNode* insertThis ) const\r
+{\r
+ TIXMLASSERT( insertThis );\r
+ TIXMLASSERT( insertThis->_document == _document );\r
+\r
+ if ( insertThis->_parent )\r
+ insertThis->_parent->Unlink( insertThis );\r
+ else\r
+ insertThis->_memPool->SetTracked();\r
+}\r
+\r
+// --------- XMLText ---------- //\r
+char* XMLText::ParseDeep( char* p, StrPair* )\r
+{\r
+ const char* start = p;\r
+ if ( this->CData() ) {\r
+ p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION );\r
+ if ( !p ) {\r
+ _document->SetError( XML_ERROR_PARSING_CDATA, start, 0 );\r
+ }\r
+ return p;\r
+ }\r
+ else {\r
+ int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;\r
+ if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {\r
+ flags |= StrPair::NEEDS_WHITESPACE_COLLAPSING;\r
+ }\r
+\r
+ p = _value.ParseText( p, "<", flags );\r
+ if ( p && *p ) {\r
+ return p-1;\r
+ }\r
+ if ( !p ) {\r
+ _document->SetError( XML_ERROR_PARSING_TEXT, start, 0 );\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const\r
+{\r
+ if ( !doc ) {\r
+ doc = _document;\r
+ }\r
+ XMLText* text = doc->NewText( Value() ); // fixme: this will always allocate memory. Intern?\r
+ text->SetCData( this->CData() );\r
+ return text;\r
+}\r
+\r
+\r
+bool XMLText::ShallowEqual( const XMLNode* compare ) const\r
+{\r
+ const XMLText* text = compare->ToText();\r
+ return ( text && XMLUtil::StringEqual( text->Value(), Value() ) );\r
+}\r
+\r
+\r
+bool XMLText::Accept( XMLVisitor* visitor ) const\r
+{\r
+ TIXMLASSERT( visitor );\r
+ return visitor->Visit( *this );\r
+}\r
+\r
+\r
+// --------- XMLComment ---------- //\r
+\r
+XMLComment::XMLComment( XMLDocument* doc ) : XMLNode( doc )\r
+{\r
+}\r
+\r
+\r
+XMLComment::~XMLComment()\r
+{\r
+}\r
+\r
+\r
+char* XMLComment::ParseDeep( char* p, StrPair* )\r
+{\r
+ // Comment parses as text.\r
+ const char* start = p;\r
+ p = _value.ParseText( p, "-->", StrPair::COMMENT );\r
+ if ( p == 0 ) {\r
+ _document->SetError( XML_ERROR_PARSING_COMMENT, start, 0 );\r
+ }\r
+ return p;\r
+}\r
+\r
+\r
+XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const\r
+{\r
+ if ( !doc ) {\r
+ doc = _document;\r
+ }\r
+ XMLComment* comment = doc->NewComment( Value() ); // fixme: this will always allocate memory. Intern?\r
+ return comment;\r
+}\r
+\r
+\r
+bool XMLComment::ShallowEqual( const XMLNode* compare ) const\r
+{\r
+ TIXMLASSERT( compare );\r
+ const XMLComment* comment = compare->ToComment();\r
+ return ( comment && XMLUtil::StringEqual( comment->Value(), Value() ));\r
+}\r
+\r
+\r
+bool XMLComment::Accept( XMLVisitor* visitor ) const\r
+{\r
+ TIXMLASSERT( visitor );\r
+ return visitor->Visit( *this );\r
+}\r
+\r
+\r
+// --------- XMLDeclaration ---------- //\r
+\r
+XMLDeclaration::XMLDeclaration( XMLDocument* doc ) : XMLNode( doc )\r
+{\r
+}\r
+\r
+\r
+XMLDeclaration::~XMLDeclaration()\r
+{\r
+ //printf( "~XMLDeclaration\n" );\r
+}\r
+\r
+\r
+char* XMLDeclaration::ParseDeep( char* p, StrPair* )\r
+{\r
+ // Declaration parses as text.\r
+ const char* start = p;\r
+ p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION );\r
+ if ( p == 0 ) {\r
+ _document->SetError( XML_ERROR_PARSING_DECLARATION, start, 0 );\r
+ }\r
+ return p;\r
+}\r
+\r
+\r
+XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const\r
+{\r
+ if ( !doc ) {\r
+ doc = _document;\r
+ }\r
+ XMLDeclaration* dec = doc->NewDeclaration( Value() ); // fixme: this will always allocate memory. Intern?\r
+ return dec;\r
+}\r
+\r
+\r
+bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const\r
+{\r
+ TIXMLASSERT( compare );\r
+ const XMLDeclaration* declaration = compare->ToDeclaration();\r
+ return ( declaration && XMLUtil::StringEqual( declaration->Value(), Value() ));\r
+}\r
+\r
+\r
+\r
+bool XMLDeclaration::Accept( XMLVisitor* visitor ) const\r
+{\r
+ TIXMLASSERT( visitor );\r
+ return visitor->Visit( *this );\r
+}\r
+\r
+// --------- XMLUnknown ---------- //\r
+\r
+XMLUnknown::XMLUnknown( XMLDocument* doc ) : XMLNode( doc )\r
+{\r
+}\r
+\r
+\r
+XMLUnknown::~XMLUnknown()\r
+{\r
+}\r
+\r
+\r
+char* XMLUnknown::ParseDeep( char* p, StrPair* )\r
+{\r
+ // Unknown parses as text.\r
+ const char* start = p;\r
+\r
+ p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION );\r
+ if ( !p ) {\r
+ _document->SetError( XML_ERROR_PARSING_UNKNOWN, start, 0 );\r
+ }\r
+ return p;\r
+}\r
+\r
+\r
+XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const\r
+{\r
+ if ( !doc ) {\r
+ doc = _document;\r
+ }\r
+ XMLUnknown* text = doc->NewUnknown( Value() ); // fixme: this will always allocate memory. Intern?\r
+ return text;\r
+}\r
+\r
+\r
+bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const\r
+{\r
+ TIXMLASSERT( compare );\r
+ const XMLUnknown* unknown = compare->ToUnknown();\r
+ return ( unknown && XMLUtil::StringEqual( unknown->Value(), Value() ));\r
+}\r
+\r
+\r
+bool XMLUnknown::Accept( XMLVisitor* visitor ) const\r
+{\r
+ TIXMLASSERT( visitor );\r
+ return visitor->Visit( *this );\r
+}\r
+\r
+// --------- XMLAttribute ---------- //\r
+\r
+const char* XMLAttribute::Name() const \r
+{\r
+ return _name.GetStr();\r
+}\r
+\r
+const char* XMLAttribute::Value() const \r
+{\r
+ return _value.GetStr();\r
+}\r
+\r
+char* XMLAttribute::ParseDeep( char* p, bool processEntities )\r
+{\r
+ // Parse using the name rules: bug fix, was using ParseText before\r
+ p = _name.ParseName( p );\r
+ if ( !p || !*p ) {\r
+ return 0;\r
+ }\r
+\r
+ // Skip white space before =\r
+ p = XMLUtil::SkipWhiteSpace( p );\r
+ if ( *p != '=' ) {\r
+ return 0;\r
+ }\r
+\r
+ ++p; // move up to opening quote\r
+ p = XMLUtil::SkipWhiteSpace( p );\r
+ if ( *p != '\"' && *p != '\'' ) {\r
+ return 0;\r
+ }\r
+\r
+ char endTag[2] = { *p, 0 };\r
+ ++p; // move past opening quote\r
+\r
+ p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES );\r
+ return p;\r
+}\r
+\r
+\r
+void XMLAttribute::SetName( const char* n )\r
+{\r
+ _name.SetStr( n );\r
+}\r
+\r
+\r
+XMLError XMLAttribute::QueryIntValue( int* value ) const\r
+{\r
+ if ( XMLUtil::ToInt( Value(), value )) {\r
+ return XML_NO_ERROR;\r
+ }\r
+ return XML_WRONG_ATTRIBUTE_TYPE;\r
+}\r
+\r
+\r
+XMLError XMLAttribute::QueryUnsignedValue( unsigned int* value ) const\r
+{\r
+ if ( XMLUtil::ToUnsigned( Value(), value )) {\r
+ return XML_NO_ERROR;\r
+ }\r
+ return XML_WRONG_ATTRIBUTE_TYPE;\r
+}\r
+\r
+\r
+XMLError XMLAttribute::QueryBoolValue( bool* value ) const\r
+{\r
+ if ( XMLUtil::ToBool( Value(), value )) {\r
+ return XML_NO_ERROR;\r
+ }\r
+ return XML_WRONG_ATTRIBUTE_TYPE;\r
+}\r
+\r
+\r
+XMLError XMLAttribute::QueryFloatValue( float* value ) const\r
+{\r
+ if ( XMLUtil::ToFloat( Value(), value )) {\r
+ return XML_NO_ERROR;\r
+ }\r
+ return XML_WRONG_ATTRIBUTE_TYPE;\r
+}\r
+\r
+\r
+XMLError XMLAttribute::QueryDoubleValue( double* value ) const\r
+{\r
+ if ( XMLUtil::ToDouble( Value(), value )) {\r
+ return XML_NO_ERROR;\r
+ }\r
+ return XML_WRONG_ATTRIBUTE_TYPE;\r
+}\r
+\r
+\r
+void XMLAttribute::SetAttribute( const char* v )\r
+{\r
+ _value.SetStr( v );\r
+}\r
+\r
+\r
+void XMLAttribute::SetAttribute( int v )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ _value.SetStr( buf );\r
+}\r
+\r
+\r
+void XMLAttribute::SetAttribute( unsigned v )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ _value.SetStr( buf );\r
+}\r
+\r
+\r
+void XMLAttribute::SetAttribute( bool v )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ _value.SetStr( buf );\r
+}\r
+\r
+void XMLAttribute::SetAttribute( double v )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ _value.SetStr( buf );\r
+}\r
+\r
+void XMLAttribute::SetAttribute( float v )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ _value.SetStr( buf );\r
+}\r
+\r
+\r
+// --------- XMLElement ---------- //\r
+XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),\r
+ _closingType( 0 ),\r
+ _rootAttribute( 0 )\r
+{\r
+}\r
+\r
+\r
+XMLElement::~XMLElement()\r
+{\r
+ while( _rootAttribute ) {\r
+ XMLAttribute* next = _rootAttribute->_next;\r
+ DeleteAttribute( _rootAttribute );\r
+ _rootAttribute = next;\r
+ }\r
+}\r
+\r
+\r
+const XMLAttribute* XMLElement::FindAttribute( const char* name ) const\r
+{\r
+ for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {\r
+ if ( XMLUtil::StringEqual( a->Name(), name ) ) {\r
+ return a;\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+const char* XMLElement::Attribute( const char* name, const char* value ) const\r
+{\r
+ const XMLAttribute* a = FindAttribute( name );\r
+ if ( !a ) {\r
+ return 0;\r
+ }\r
+ if ( !value || XMLUtil::StringEqual( a->Value(), value )) {\r
+ return a->Value();\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+const char* XMLElement::GetText() const\r
+{\r
+ if ( FirstChild() && FirstChild()->ToText() ) {\r
+ return FirstChild()->Value();\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+void XMLElement::SetText( const char* inText )\r
+{\r
+ if ( FirstChild() && FirstChild()->ToText() )\r
+ FirstChild()->SetValue( inText );\r
+ else {\r
+ XMLText* theText = GetDocument()->NewText( inText );\r
+ InsertFirstChild( theText );\r
+ }\r
+}\r
+\r
+\r
+void XMLElement::SetText( int v ) \r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ SetText( buf );\r
+}\r
+\r
+\r
+void XMLElement::SetText( unsigned v ) \r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ SetText( buf );\r
+}\r
+\r
+\r
+void XMLElement::SetText( bool v ) \r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ SetText( buf );\r
+}\r
+\r
+\r
+void XMLElement::SetText( float v ) \r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ SetText( buf );\r
+}\r
+\r
+\r
+void XMLElement::SetText( double v ) \r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ SetText( buf );\r
+}\r
+\r
+\r
+XMLError XMLElement::QueryIntText( int* ival ) const\r
+{\r
+ if ( FirstChild() && FirstChild()->ToText() ) {\r
+ const char* t = FirstChild()->Value();\r
+ if ( XMLUtil::ToInt( t, ival ) ) {\r
+ return XML_SUCCESS;\r
+ }\r
+ return XML_CAN_NOT_CONVERT_TEXT;\r
+ }\r
+ return XML_NO_TEXT_NODE;\r
+}\r
+\r
+\r
+XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const\r
+{\r
+ if ( FirstChild() && FirstChild()->ToText() ) {\r
+ const char* t = FirstChild()->Value();\r
+ if ( XMLUtil::ToUnsigned( t, uval ) ) {\r
+ return XML_SUCCESS;\r
+ }\r
+ return XML_CAN_NOT_CONVERT_TEXT;\r
+ }\r
+ return XML_NO_TEXT_NODE;\r
+}\r
+\r
+\r
+XMLError XMLElement::QueryBoolText( bool* bval ) const\r
+{\r
+ if ( FirstChild() && FirstChild()->ToText() ) {\r
+ const char* t = FirstChild()->Value();\r
+ if ( XMLUtil::ToBool( t, bval ) ) {\r
+ return XML_SUCCESS;\r
+ }\r
+ return XML_CAN_NOT_CONVERT_TEXT;\r
+ }\r
+ return XML_NO_TEXT_NODE;\r
+}\r
+\r
+\r
+XMLError XMLElement::QueryDoubleText( double* dval ) const\r
+{\r
+ if ( FirstChild() && FirstChild()->ToText() ) {\r
+ const char* t = FirstChild()->Value();\r
+ if ( XMLUtil::ToDouble( t, dval ) ) {\r
+ return XML_SUCCESS;\r
+ }\r
+ return XML_CAN_NOT_CONVERT_TEXT;\r
+ }\r
+ return XML_NO_TEXT_NODE;\r
+}\r
+\r
+\r
+XMLError XMLElement::QueryFloatText( float* fval ) const\r
+{\r
+ if ( FirstChild() && FirstChild()->ToText() ) {\r
+ const char* t = FirstChild()->Value();\r
+ if ( XMLUtil::ToFloat( t, fval ) ) {\r
+ return XML_SUCCESS;\r
+ }\r
+ return XML_CAN_NOT_CONVERT_TEXT;\r
+ }\r
+ return XML_NO_TEXT_NODE;\r
+}\r
+\r
+\r
+\r
+XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )\r
+{\r
+ XMLAttribute* last = 0;\r
+ XMLAttribute* attrib = 0;\r
+ for( attrib = _rootAttribute;\r
+ attrib;\r
+ last = attrib, attrib = attrib->_next ) {\r
+ if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {\r
+ break;\r
+ }\r
+ }\r
+ if ( !attrib ) {\r
+ TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );\r
+ attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();\r
+ attrib->_memPool = &_document->_attributePool;\r
+ if ( last ) {\r
+ last->_next = attrib;\r
+ }\r
+ else {\r
+ _rootAttribute = attrib;\r
+ }\r
+ attrib->SetName( name );\r
+ attrib->_memPool->SetTracked(); // always created and linked.\r
+ }\r
+ return attrib;\r
+}\r
+\r
+\r
+void XMLElement::DeleteAttribute( const char* name )\r
+{\r
+ XMLAttribute* prev = 0;\r
+ for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {\r
+ if ( XMLUtil::StringEqual( name, a->Name() ) ) {\r
+ if ( prev ) {\r
+ prev->_next = a->_next;\r
+ }\r
+ else {\r
+ _rootAttribute = a->_next;\r
+ }\r
+ DeleteAttribute( a );\r
+ break;\r
+ }\r
+ prev = a;\r
+ }\r
+}\r
+\r
+\r
+char* XMLElement::ParseAttributes( char* p )\r
+{\r
+ const char* start = p;\r
+ XMLAttribute* prevAttribute = 0;\r
+\r
+ // Read the attributes.\r
+ while( p ) {\r
+ p = XMLUtil::SkipWhiteSpace( p );\r
+ if ( !(*p) ) {\r
+ _document->SetError( XML_ERROR_PARSING_ELEMENT, start, Name() );\r
+ return 0;\r
+ }\r
+\r
+ // attribute.\r
+ if (XMLUtil::IsNameStartChar( *p ) ) {\r
+ TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );\r
+ XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();\r
+ attrib->_memPool = &_document->_attributePool;\r
+ attrib->_memPool->SetTracked();\r
+\r
+ p = attrib->ParseDeep( p, _document->ProcessEntities() );\r
+ if ( !p || Attribute( attrib->Name() ) ) {\r
+ DeleteAttribute( attrib );\r
+ _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, start, p );\r
+ return 0;\r
+ }\r
+ // There is a minor bug here: if the attribute in the source xml\r
+ // document is duplicated, it will not be detected and the\r
+ // attribute will be doubly added. However, tracking the 'prevAttribute'\r
+ // avoids re-scanning the attribute list. Preferring performance for\r
+ // now, may reconsider in the future.\r
+ if ( prevAttribute ) {\r
+ prevAttribute->_next = attrib;\r
+ }\r
+ else {\r
+ _rootAttribute = attrib;\r
+ }\r
+ prevAttribute = attrib;\r
+ }\r
+ // end of the tag\r
+ else if ( *p == '>' ) {\r
+ ++p;\r
+ break;\r
+ }\r
+ // end of the tag\r
+ else if ( *p == '/' && *(p+1) == '>' ) {\r
+ _closingType = CLOSED;\r
+ return p+2; // done; sealed element.\r
+ }\r
+ else {\r
+ _document->SetError( XML_ERROR_PARSING_ELEMENT, start, p );\r
+ return 0;\r
+ }\r
+ }\r
+ return p;\r
+}\r
+\r
+void XMLElement::DeleteAttribute( XMLAttribute* attribute )\r
+{\r
+ if ( attribute == 0 ) {\r
+ return;\r
+ }\r
+ MemPool* pool = attribute->_memPool;\r
+ attribute->~XMLAttribute();\r
+ pool->Free( attribute );\r
+}\r
+\r
+//\r
+// <ele></ele>\r
+// <ele>foo<b>bar</b></ele>\r
+//\r
+char* XMLElement::ParseDeep( char* p, StrPair* strPair )\r
+{\r
+ // Read the element name.\r
+ p = XMLUtil::SkipWhiteSpace( p );\r
+\r
+ // The closing element is the </element> form. It is\r
+ // parsed just like a regular element then deleted from\r
+ // the DOM.\r
+ if ( *p == '/' ) {\r
+ _closingType = CLOSING;\r
+ ++p;\r
+ }\r
+\r
+ p = _value.ParseName( p );\r
+ if ( _value.Empty() ) {\r
+ return 0;\r
+ }\r
+\r
+ p = ParseAttributes( p );\r
+ if ( !p || !*p || _closingType ) {\r
+ return p;\r
+ }\r
+\r
+ p = XMLNode::ParseDeep( p, strPair );\r
+ return p;\r
+}\r
+\r
+\r
+\r
+XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const\r
+{\r
+ if ( !doc ) {\r
+ doc = _document;\r
+ }\r
+ XMLElement* element = doc->NewElement( Value() ); // fixme: this will always allocate memory. Intern?\r
+ for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) {\r
+ element->SetAttribute( a->Name(), a->Value() ); // fixme: this will always allocate memory. Intern?\r
+ }\r
+ return element;\r
+}\r
+\r
+\r
+bool XMLElement::ShallowEqual( const XMLNode* compare ) const\r
+{\r
+ TIXMLASSERT( compare );\r
+ const XMLElement* other = compare->ToElement();\r
+ if ( other && XMLUtil::StringEqual( other->Name(), Name() )) {\r
+\r
+ const XMLAttribute* a=FirstAttribute();\r
+ const XMLAttribute* b=other->FirstAttribute();\r
+\r
+ while ( a && b ) {\r
+ if ( !XMLUtil::StringEqual( a->Value(), b->Value() ) ) {\r
+ return false;\r
+ }\r
+ a = a->Next();\r
+ b = b->Next();\r
+ }\r
+ if ( a || b ) {\r
+ // different count\r
+ return false;\r
+ }\r
+ return true;\r
+ }\r
+ return false;\r
+}\r
+\r
+\r
+bool XMLElement::Accept( XMLVisitor* visitor ) const\r
+{\r
+ TIXMLASSERT( visitor );\r
+ if ( visitor->VisitEnter( *this, _rootAttribute ) ) {\r
+ for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {\r
+ if ( !node->Accept( visitor ) ) {\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ return visitor->VisitExit( *this );\r
+}\r
+\r
+\r
+// --------- XMLDocument ----------- //\r
+\r
+// Warning: List must match 'enum XMLError'\r
+const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {\r
+ "XML_SUCCESS",\r
+ "XML_NO_ATTRIBUTE",\r
+ "XML_WRONG_ATTRIBUTE_TYPE",\r
+ "XML_ERROR_FILE_NOT_FOUND",\r
+ "XML_ERROR_FILE_COULD_NOT_BE_OPENED",\r
+ "XML_ERROR_FILE_READ_ERROR",\r
+ "XML_ERROR_ELEMENT_MISMATCH",\r
+ "XML_ERROR_PARSING_ELEMENT",\r
+ "XML_ERROR_PARSING_ATTRIBUTE",\r
+ "XML_ERROR_IDENTIFYING_TAG",\r
+ "XML_ERROR_PARSING_TEXT",\r
+ "XML_ERROR_PARSING_CDATA",\r
+ "XML_ERROR_PARSING_COMMENT",\r
+ "XML_ERROR_PARSING_DECLARATION",\r
+ "XML_ERROR_PARSING_UNKNOWN",\r
+ "XML_ERROR_EMPTY_DOCUMENT",\r
+ "XML_ERROR_MISMATCHED_ELEMENT",\r
+ "XML_ERROR_PARSING",\r
+ "XML_CAN_NOT_CONVERT_TEXT",\r
+ "XML_NO_TEXT_NODE"\r
+};\r
+\r
+\r
+XMLDocument::XMLDocument( bool processEntities, Whitespace whitespace ) :\r
+ XMLNode( 0 ),\r
+ _writeBOM( false ),\r
+ _processEntities( processEntities ),\r
+ _errorID( XML_NO_ERROR ),\r
+ _whitespace( whitespace ),\r
+ _errorStr1( 0 ),\r
+ _errorStr2( 0 ),\r
+ _charBuffer( 0 )\r
+{\r
+ // avoid VC++ C4355 warning about 'this' in initializer list (C4355 is off by default in VS2012+)\r
+ _document = this;\r
+}\r
+\r
+\r
+XMLDocument::~XMLDocument()\r
+{\r
+ Clear();\r
+}\r
+\r
+\r
+void XMLDocument::Clear()\r
+{\r
+ DeleteChildren();\r
+\r
+#ifdef DEBUG\r
+ const bool hadError = Error();\r
+#endif\r
+ _errorID = XML_NO_ERROR;\r
+ _errorStr1 = 0;\r
+ _errorStr2 = 0;\r
+\r
+ delete [] _charBuffer;\r
+ _charBuffer = 0;\r
+\r
+#if 0\r
+ _textPool.Trace( "text" );\r
+ _elementPool.Trace( "element" );\r
+ _commentPool.Trace( "comment" );\r
+ _attributePool.Trace( "attribute" );\r
+#endif\r
+ \r
+#ifdef DEBUG\r
+ if ( !hadError ) {\r
+ TIXMLASSERT( _elementPool.CurrentAllocs() == _elementPool.Untracked() );\r
+ TIXMLASSERT( _attributePool.CurrentAllocs() == _attributePool.Untracked() );\r
+ TIXMLASSERT( _textPool.CurrentAllocs() == _textPool.Untracked() );\r
+ TIXMLASSERT( _commentPool.CurrentAllocs() == _commentPool.Untracked() );\r
+ }\r
+#endif\r
+}\r
+\r
+\r
+XMLElement* XMLDocument::NewElement( const char* name )\r
+{\r
+ TIXMLASSERT( sizeof( XMLElement ) == _elementPool.ItemSize() );\r
+ XMLElement* ele = new (_elementPool.Alloc()) XMLElement( this );\r
+ ele->_memPool = &_elementPool;\r
+ ele->SetName( name );\r
+ return ele;\r
+}\r
+\r
+\r
+XMLComment* XMLDocument::NewComment( const char* str )\r
+{\r
+ TIXMLASSERT( sizeof( XMLComment ) == _commentPool.ItemSize() );\r
+ XMLComment* comment = new (_commentPool.Alloc()) XMLComment( this );\r
+ comment->_memPool = &_commentPool;\r
+ comment->SetValue( str );\r
+ return comment;\r
+}\r
+\r
+\r
+XMLText* XMLDocument::NewText( const char* str )\r
+{\r
+ TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );\r
+ XMLText* text = new (_textPool.Alloc()) XMLText( this );\r
+ text->_memPool = &_textPool;\r
+ text->SetValue( str );\r
+ return text;\r
+}\r
+\r
+\r
+XMLDeclaration* XMLDocument::NewDeclaration( const char* str )\r
+{\r
+ TIXMLASSERT( sizeof( XMLDeclaration ) == _commentPool.ItemSize() );\r
+ XMLDeclaration* dec = new (_commentPool.Alloc()) XMLDeclaration( this );\r
+ dec->_memPool = &_commentPool;\r
+ dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );\r
+ return dec;\r
+}\r
+\r
+\r
+XMLUnknown* XMLDocument::NewUnknown( const char* str )\r
+{\r
+ TIXMLASSERT( sizeof( XMLUnknown ) == _commentPool.ItemSize() );\r
+ XMLUnknown* unk = new (_commentPool.Alloc()) XMLUnknown( this );\r
+ unk->_memPool = &_commentPool;\r
+ unk->SetValue( str );\r
+ return unk;\r
+}\r
+\r
+static FILE* callfopen( const char* filepath, const char* mode )\r
+{\r
+ TIXMLASSERT( filepath );\r
+ TIXMLASSERT( mode );\r
+#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)\r
+ FILE* fp = 0;\r
+ errno_t err = fopen_s( &fp, filepath, mode );\r
+ if ( err ) {\r
+ return 0;\r
+ }\r
+#else\r
+ FILE* fp = fopen( filepath, mode );\r
+#endif\r
+ return fp;\r
+}\r
+ \r
+void XMLDocument::DeleteNode( XMLNode* node ) {\r
+ TIXMLASSERT( node );\r
+ TIXMLASSERT(node->_document == this );\r
+ if (node->_parent) {\r
+ node->_parent->DeleteChild( node );\r
+ }\r
+ else {\r
+ // Isn't in the tree.\r
+ // Use the parent delete.\r
+ // Also, we need to mark it tracked: we 'know'\r
+ // it was never used.\r
+ node->_memPool->SetTracked();\r
+ // Call the static XMLNode version:\r
+ XMLNode::DeleteNode(node);\r
+ }\r
+}\r
+\r
+\r
+XMLError XMLDocument::LoadFile( const char* filename )\r
+{\r
+ Clear();\r
+ FILE* fp = callfopen( filename, "rb" );\r
+ if ( !fp ) {\r
+ SetError( XML_ERROR_FILE_NOT_FOUND, filename, 0 );\r
+ return _errorID;\r
+ }\r
+ LoadFile( fp );\r
+ fclose( fp );\r
+ return _errorID;\r
+}\r
+\r
+// This is likely overengineered template art to have a check that unsigned long value incremented\r
+// by one still fits into size_t. If size_t type is larger than unsigned long type\r
+// (x86_64-w64-mingw32 target) then the check is redundant and gcc and clang emit\r
+// -Wtype-limits warning. This piece makes the compiler select code with a check when a check\r
+// is useful and code with no check when a check is redundant depending on how size_t and unsigned long\r
+// types sizes relate to each other.\r
+template\r
+<bool = (sizeof(unsigned long) >= sizeof(size_t))>\r
+struct LongFitsIntoSizeTMinusOne {\r
+ static bool Fits( unsigned long value )\r
+ {\r
+ return value < (size_t)-1;\r
+ }\r
+};\r
+\r
+template <>\r
+bool LongFitsIntoSizeTMinusOne<false>::Fits( unsigned long /*value*/ )\r
+{\r
+ return true;\r
+}\r
+\r
+XMLError XMLDocument::LoadFile( FILE* fp )\r
+{\r
+ Clear();\r
+\r
+ fseek( fp, 0, SEEK_SET );\r
+ if ( fgetc( fp ) == EOF && ferror( fp ) != 0 ) {\r
+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );\r
+ return _errorID;\r
+ }\r
+\r
+ fseek( fp, 0, SEEK_END );\r
+ const long filelength = ftell( fp );\r
+ fseek( fp, 0, SEEK_SET );\r
+ if ( filelength == -1L ) {\r
+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );\r
+ return _errorID;\r
+ }\r
+ TIXMLASSERT( filelength >= 0 );\r
+\r
+ if ( !LongFitsIntoSizeTMinusOne<>::Fits( filelength ) ) {\r
+ // Cannot handle files which won't fit in buffer together with null terminator\r
+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );\r
+ return _errorID;\r
+ }\r
+\r
+ if ( filelength == 0 ) {\r
+ SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );\r
+ return _errorID;\r
+ }\r
+\r
+ const size_t size = filelength;\r
+ TIXMLASSERT( _charBuffer == 0 );\r
+ _charBuffer = new char[size+1];\r
+ size_t read = fread( _charBuffer, 1, size, fp );\r
+ if ( read != size ) {\r
+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );\r
+ return _errorID;\r
+ }\r
+\r
+ _charBuffer[size] = 0;\r
+\r
+ Parse();\r
+ return _errorID;\r
+}\r
+\r
+\r
+XMLError XMLDocument::SaveFile( const char* filename, bool compact )\r
+{\r
+ FILE* fp = callfopen( filename, "w" );\r
+ if ( !fp ) {\r
+ SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, filename, 0 );\r
+ return _errorID;\r
+ }\r
+ SaveFile(fp, compact);\r
+ fclose( fp );\r
+ return _errorID;\r
+}\r
+\r
+\r
+XMLError XMLDocument::SaveFile( FILE* fp, bool compact )\r
+{\r
+ // Clear any error from the last save, otherwise it will get reported\r
+ // for *this* call.\r
+ SetError( XML_NO_ERROR, 0, 0 );\r
+ XMLPrinter stream( fp, compact );\r
+ Print( &stream );\r
+ return _errorID;\r
+}\r
+\r
+\r
+XMLError XMLDocument::Parse( const char* p, size_t len )\r
+{\r
+ Clear();\r
+\r
+ if ( len == 0 || !p || !*p ) {\r
+ SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );\r
+ return _errorID;\r
+ }\r
+ if ( len == (size_t)(-1) ) {\r
+ len = strlen( p );\r
+ }\r
+ TIXMLASSERT( _charBuffer == 0 );\r
+ _charBuffer = new char[ len+1 ];\r
+ memcpy( _charBuffer, p, len );\r
+ _charBuffer[len] = 0;\r
+\r
+ Parse();\r
+ if ( Error() ) {\r
+ // clean up now essentially dangling memory.\r
+ // and the parse fail can put objects in the\r
+ // pools that are dead and inaccessible.\r
+ DeleteChildren();\r
+ _elementPool.Clear();\r
+ _attributePool.Clear();\r
+ _textPool.Clear();\r
+ _commentPool.Clear();\r
+ }\r
+ return _errorID;\r
+}\r
+\r
+\r
+void XMLDocument::Print( XMLPrinter* streamer ) const\r
+{\r
+ if ( streamer ) {\r
+ Accept( streamer );\r
+ }\r
+ else {\r
+ XMLPrinter stdoutStreamer( stdout );\r
+ Accept( &stdoutStreamer );\r
+ }\r
+}\r
+\r
+\r
+void XMLDocument::SetError( XMLError error, const char* str1, const char* str2 )\r
+{\r
+ TIXMLASSERT( error >= 0 && error < XML_ERROR_COUNT );\r
+ _errorID = error;\r
+ _errorStr1 = str1;\r
+ _errorStr2 = str2;\r
+}\r
+\r
+const char* XMLDocument::ErrorName() const\r
+{\r
+ TIXMLASSERT( _errorID >= 0 && _errorID < XML_ERROR_COUNT );\r
+ const char* errorName = _errorNames[_errorID];\r
+ TIXMLASSERT( errorName && errorName[0] );\r
+ return errorName;\r
+}\r
+\r
+void XMLDocument::PrintError() const\r
+{\r
+ if ( Error() ) {\r
+ static const int LEN = 20;\r
+ char buf1[LEN] = { 0 };\r
+ char buf2[LEN] = { 0 };\r
+\r
+ if ( _errorStr1 ) {\r
+ TIXML_SNPRINTF( buf1, LEN, "%s", _errorStr1 );\r
+ }\r
+ if ( _errorStr2 ) {\r
+ TIXML_SNPRINTF( buf2, LEN, "%s", _errorStr2 );\r
+ }\r
+\r
+ // Should check INT_MIN <= _errorID && _errorId <= INT_MAX, but that\r
+ // causes a clang "always true" -Wtautological-constant-out-of-range-compare warning\r
+ TIXMLASSERT( 0 <= _errorID && XML_ERROR_COUNT - 1 <= INT_MAX );\r
+ printf( "XMLDocument error id=%d '%s' str1=%s str2=%s\n",\r
+ static_cast<int>( _errorID ), ErrorName(), buf1, buf2 );\r
+ }\r
+}\r
+\r
+void XMLDocument::Parse()\r
+{\r
+ TIXMLASSERT( NoChildren() ); // Clear() must have been called previously\r
+ TIXMLASSERT( _charBuffer );\r
+ char* p = _charBuffer;\r
+ p = XMLUtil::SkipWhiteSpace( p );\r
+ p = const_cast<char*>( XMLUtil::ReadBOM( p, &_writeBOM ) );\r
+ if ( !*p ) {\r
+ SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );\r
+ return;\r
+ }\r
+ ParseDeep(p, 0 );\r
+}\r
+\r
+XMLPrinter::XMLPrinter( FILE* file, bool compact, int depth ) :\r
+ _elementJustOpened( false ),\r
+ _firstElement( true ),\r
+ _fp( file ),\r
+ _depth( depth ),\r
+ _textDepth( -1 ),\r
+ _processEntities( true ),\r
+ _compactMode( compact )\r
+{\r
+ for( int i=0; i<ENTITY_RANGE; ++i ) {\r
+ _entityFlag[i] = false;\r
+ _restrictedEntityFlag[i] = false;\r
+ }\r
+ for( int i=0; i<NUM_ENTITIES; ++i ) {\r
+ const char entityValue = entities[i].value;\r
+ TIXMLASSERT( 0 <= entityValue && entityValue < ENTITY_RANGE );\r
+ _entityFlag[ (unsigned char)entityValue ] = true;\r
+ }\r
+ _restrictedEntityFlag[(unsigned char)'&'] = true;\r
+ _restrictedEntityFlag[(unsigned char)'<'] = true;\r
+ _restrictedEntityFlag[(unsigned char)'>'] = true; // not required, but consistency is nice\r
+ _buffer.Push( 0 );\r
+}\r
+\r
+\r
+void XMLPrinter::Print( const char* format, ... )\r
+{\r
+ va_list va;\r
+ va_start( va, format );\r
+\r
+ if ( _fp ) {\r
+ vfprintf( _fp, format, va );\r
+ }\r
+ else {\r
+ const int len = TIXML_VSCPRINTF( format, va );\r
+ // Close out and re-start the va-args\r
+ va_end( va );\r
+ TIXMLASSERT( len >= 0 );\r
+ va_start( va, format );\r
+ TIXMLASSERT( _buffer.Size() > 0 && _buffer[_buffer.Size() - 1] == 0 );\r
+ char* p = _buffer.PushArr( len ) - 1; // back up over the null terminator.\r
+ TIXML_VSNPRINTF( p, len+1, format, va );\r
+ }\r
+ va_end( va );\r
+}\r
+\r
+\r
+void XMLPrinter::PrintSpace( int depth )\r
+{\r
+ for( int i=0; i<depth; ++i ) {\r
+ Print( " " );\r
+ }\r
+}\r
+\r
+\r
+void XMLPrinter::PrintString( const char* p, bool restricted )\r
+{\r
+ // Look for runs of bytes between entities to print.\r
+ const char* q = p;\r
+\r
+ if ( _processEntities ) {\r
+ const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;\r
+ while ( *q ) {\r
+ TIXMLASSERT( p <= q );\r
+ // Remember, char is sometimes signed. (How many times has that bitten me?)\r
+ if ( *q > 0 && *q < ENTITY_RANGE ) {\r
+ // Check for entities. If one is found, flush\r
+ // the stream up until the entity, write the\r
+ // entity, and keep looking.\r
+ if ( flag[(unsigned char)(*q)] ) {\r
+ while ( p < q ) {\r
+ const size_t delta = q - p;\r
+ // %.*s accepts type int as "precision"\r
+ const int toPrint = ( INT_MAX < delta ) ? INT_MAX : (int)delta;\r
+ Print( "%.*s", toPrint, p );\r
+ p += toPrint;\r
+ }\r
+ bool entityPatternPrinted = false;\r
+ for( int i=0; i<NUM_ENTITIES; ++i ) {\r
+ if ( entities[i].value == *q ) {\r
+ Print( "&%s;", entities[i].pattern );\r
+ entityPatternPrinted = true;\r
+ break;\r
+ }\r
+ }\r
+ if ( !entityPatternPrinted ) {\r
+ // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release\r
+ TIXMLASSERT( false );\r
+ }\r
+ ++p;\r
+ }\r
+ }\r
+ ++q;\r
+ TIXMLASSERT( p <= q );\r
+ }\r
+ }\r
+ // Flush the remaining string. This will be the entire\r
+ // string if an entity wasn't found.\r
+ TIXMLASSERT( p <= q );\r
+ if ( !_processEntities || ( p < q ) ) {\r
+ Print( "%s", p );\r
+ }\r
+}\r
+\r
+\r
+void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )\r
+{\r
+ if ( writeBOM ) {\r
+ static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };\r
+ Print( "%s", bom );\r
+ }\r
+ if ( writeDec ) {\r
+ PushDeclaration( "xml version=\"1.0\"" );\r
+ }\r
+}\r
+\r
+\r
+void XMLPrinter::OpenElement( const char* name, bool compactMode )\r
+{\r
+ SealElementIfJustOpened();\r
+ _stack.Push( name );\r
+\r
+ if ( _textDepth < 0 && !_firstElement && !compactMode ) {\r
+ Print( "\n" );\r
+ }\r
+ if ( !compactMode ) {\r
+ PrintSpace( _depth );\r
+ }\r
+\r
+ Print( "<%s", name );\r
+ _elementJustOpened = true;\r
+ _firstElement = false;\r
+ ++_depth;\r
+}\r
+\r
+\r
+void XMLPrinter::PushAttribute( const char* name, const char* value )\r
+{\r
+ TIXMLASSERT( _elementJustOpened );\r
+ Print( " %s=\"", name );\r
+ PrintString( value, false );\r
+ Print( "\"" );\r
+}\r
+\r
+\r
+void XMLPrinter::PushAttribute( const char* name, int v )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ PushAttribute( name, buf );\r
+}\r
+\r
+\r
+void XMLPrinter::PushAttribute( const char* name, unsigned v )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ PushAttribute( name, buf );\r
+}\r
+\r
+\r
+void XMLPrinter::PushAttribute( const char* name, bool v )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ PushAttribute( name, buf );\r
+}\r
+\r
+\r
+void XMLPrinter::PushAttribute( const char* name, double v )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( v, buf, BUF_SIZE );\r
+ PushAttribute( name, buf );\r
+}\r
+\r
+\r
+void XMLPrinter::CloseElement( bool compactMode )\r
+{\r
+ --_depth;\r
+ const char* name = _stack.Pop();\r
+\r
+ if ( _elementJustOpened ) {\r
+ Print( "/>" );\r
+ }\r
+ else {\r
+ if ( _textDepth < 0 && !compactMode) {\r
+ Print( "\n" );\r
+ PrintSpace( _depth );\r
+ }\r
+ Print( "</%s>", name );\r
+ }\r
+\r
+ if ( _textDepth == _depth ) {\r
+ _textDepth = -1;\r
+ }\r
+ if ( _depth == 0 && !compactMode) {\r
+ Print( "\n" );\r
+ }\r
+ _elementJustOpened = false;\r
+}\r
+\r
+\r
+void XMLPrinter::SealElementIfJustOpened()\r
+{\r
+ if ( !_elementJustOpened ) {\r
+ return;\r
+ }\r
+ _elementJustOpened = false;\r
+ Print( ">" );\r
+}\r
+\r
+\r
+void XMLPrinter::PushText( const char* text, bool cdata )\r
+{\r
+ _textDepth = _depth-1;\r
+\r
+ SealElementIfJustOpened();\r
+ if ( cdata ) {\r
+ Print( "<![CDATA[%s]]>", text );\r
+ }\r
+ else {\r
+ PrintString( text, true );\r
+ }\r
+}\r
+\r
+void XMLPrinter::PushText( int value )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( value, buf, BUF_SIZE );\r
+ PushText( buf, false );\r
+}\r
+\r
+\r
+void XMLPrinter::PushText( unsigned value )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( value, buf, BUF_SIZE );\r
+ PushText( buf, false );\r
+}\r
+\r
+\r
+void XMLPrinter::PushText( bool value )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( value, buf, BUF_SIZE );\r
+ PushText( buf, false );\r
+}\r
+\r
+\r
+void XMLPrinter::PushText( float value )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( value, buf, BUF_SIZE );\r
+ PushText( buf, false );\r
+}\r
+\r
+\r
+void XMLPrinter::PushText( double value )\r
+{\r
+ char buf[BUF_SIZE];\r
+ XMLUtil::ToStr( value, buf, BUF_SIZE );\r
+ PushText( buf, false );\r
+}\r
+\r
+\r
+void XMLPrinter::PushComment( const char* comment )\r
+{\r
+ SealElementIfJustOpened();\r
+ if ( _textDepth < 0 && !_firstElement && !_compactMode) {\r
+ Print( "\n" );\r
+ PrintSpace( _depth );\r
+ }\r
+ _firstElement = false;\r
+ Print( "<!--%s-->", comment );\r
+}\r
+\r
+\r
+void XMLPrinter::PushDeclaration( const char* value )\r
+{\r
+ SealElementIfJustOpened();\r
+ if ( _textDepth < 0 && !_firstElement && !_compactMode) {\r
+ Print( "\n" );\r
+ PrintSpace( _depth );\r
+ }\r
+ _firstElement = false;\r
+ Print( "<?%s?>", value );\r
+}\r
+\r
+\r
+void XMLPrinter::PushUnknown( const char* value )\r
+{\r
+ SealElementIfJustOpened();\r
+ if ( _textDepth < 0 && !_firstElement && !_compactMode) {\r
+ Print( "\n" );\r
+ PrintSpace( _depth );\r
+ }\r
+ _firstElement = false;\r
+ Print( "<!%s>", value );\r
+}\r
+\r
+\r
+bool XMLPrinter::VisitEnter( const XMLDocument& doc )\r
+{\r
+ _processEntities = doc.ProcessEntities();\r
+ if ( doc.HasBOM() ) {\r
+ PushHeader( true, false );\r
+ }\r
+ return true;\r
+}\r
+\r
+\r
+bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )\r
+{\r
+ const XMLElement* parentElem = 0;\r
+ if ( element.Parent() ) {\r
+ parentElem = element.Parent()->ToElement();\r
+ }\r
+ const bool compactMode = parentElem ? CompactMode( *parentElem ) : _compactMode;\r
+ OpenElement( element.Name(), compactMode );\r
+ while ( attribute ) {\r
+ PushAttribute( attribute->Name(), attribute->Value() );\r
+ attribute = attribute->Next();\r
+ }\r
+ return true;\r
+}\r
+\r
+\r
+bool XMLPrinter::VisitExit( const XMLElement& element )\r
+{\r
+ CloseElement( CompactMode(element) );\r
+ return true;\r
+}\r
+\r
+\r
+bool XMLPrinter::Visit( const XMLText& text )\r
+{\r
+ PushText( text.Value(), text.CData() );\r
+ return true;\r
+}\r
+\r
+\r
+bool XMLPrinter::Visit( const XMLComment& comment )\r
+{\r
+ PushComment( comment.Value() );\r
+ return true;\r
+}\r
+\r
+bool XMLPrinter::Visit( const XMLDeclaration& declaration )\r
+{\r
+ PushDeclaration( declaration.Value() );\r
+ return true;\r
+}\r
+\r
+\r
+bool XMLPrinter::Visit( const XMLUnknown& unknown )\r
+{\r
+ PushUnknown( unknown.Value() );\r
+ return true;\r
+}\r
+\r
+} // namespace tinyxml2\r
+\r
git://git.creatis.insa-lyon.fr / cpPlugins.git / blobdiff