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