Lee Thomason (grinliz) | 2812986 | 2012-02-25 21:11:20 -0800 | [diff] [blame] | 1 | /*
|
| 2 | Original code by Lee Thomason (www.grinninglizard.com)
|
| 3 |
|
| 4 | This software is provided 'as-is', without any express or implied
|
| 5 | warranty. In no event will the authors be held liable for any
|
| 6 | damages arising from the use of this software.
|
| 7 |
|
| 8 | Permission is granted to anyone to use this software for any
|
| 9 | purpose, including commercial applications, and to alter it and
|
| 10 | redistribute it freely, subject to the following restrictions:
|
| 11 |
|
| 12 | 1. The origin of this software must not be misrepresented; you must
|
| 13 | not claim that you wrote the original software. If you use this
|
| 14 | software in a product, an acknowledgment in the product documentation
|
| 15 | would be appreciated but is not required.
|
| 16 |
|
| 17 | 2. Altered source versions must be plainly marked as such, and
|
| 18 | must not be misrepresented as being the original software.
|
| 19 |
|
| 20 | 3. This notice may not be removed or altered from any source
|
| 21 | distribution.
|
| 22 | */
|
Lee Thomason (grinliz) | 9c38d13 | 2012-02-24 21:50:50 -0800 | [diff] [blame] | 23 |
|
U-Lama\Lee | 560bd47 | 2011-12-28 19:42:49 -0800 | [diff] [blame] | 24 | #include "tinyxml2.h"
|
| 25 |
|
Lee Thomason (grinliz) | bc1bfb7 | 2012-08-20 22:00:38 -0700 | [diff] [blame] | 26 | #include <new> // yes, this one new style header, is in the Android SDK.
|
Wilfred van Velzen | 67abee5 | 2016-03-25 14:01:15 +0100 | [diff] [blame] | 27 | #if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__)
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 28 | # include <stddef.h>
|
Philipp Kloke | 358202c | 2015-07-30 16:02:26 +0200 | [diff] [blame] | 29 | # include <stdarg.h>
|
Lee Thomason (grinliz) | bc1bfb7 | 2012-08-20 22:00:38 -0700 | [diff] [blame] | 30 | #else
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 31 | # include <cstddef>
|
Philipp Kloke | 358202c | 2015-07-30 16:02:26 +0200 | [diff] [blame] | 32 | # include <cstdarg>
|
Lee Thomason (grinliz) | bc1bfb7 | 2012-08-20 22:00:38 -0700 | [diff] [blame] | 33 | #endif
|
U-Lama\Lee | 560bd47 | 2011-12-28 19:42:49 -0800 | [diff] [blame] | 34 |
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 35 | #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
|
Dmitry-Me | 1ca593c | 2015-06-22 12:49:32 +0300 | [diff] [blame] | 36 | // Microsoft Visual Studio, version 2005 and higher. Not WinCE.
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 37 | /*int _snprintf_s(
|
| 38 | char *buffer,
|
| 39 | size_t sizeOfBuffer,
|
| 40 | size_t count,
|
| 41 | const char *format [,
|
| 42 | argument] ...
|
| 43 | );*/
|
PKEuS | cac7578 | 2015-08-15 18:17:27 +0200 | [diff] [blame] | 44 | static inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 45 | {
|
| 46 | va_list va;
|
| 47 | va_start( va, format );
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 48 | const int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 49 | va_end( va );
|
| 50 | return result;
|
| 51 | }
|
| 52 |
|
PKEuS | cac7578 | 2015-08-15 18:17:27 +0200 | [diff] [blame] | 53 | static inline int TIXML_VSNPRINTF( char* buffer, size_t size, const char* format, va_list va )
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 54 | {
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 55 | const int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 56 | return result;
|
| 57 | }
|
| 58 |
|
| 59 | #define TIXML_VSCPRINTF _vscprintf
|
| 60 | #define TIXML_SSCANF sscanf_s
|
| 61 | #elif defined _MSC_VER
|
| 62 | // Microsoft Visual Studio 2003 and earlier or WinCE
|
| 63 | #define TIXML_SNPRINTF _snprintf
|
| 64 | #define TIXML_VSNPRINTF _vsnprintf
|
| 65 | #define TIXML_SSCANF sscanf
|
Lee Thomason | aa8566b | 2015-06-19 16:52:40 -0700 | [diff] [blame] | 66 | #if (_MSC_VER < 1400 ) && (!defined WINCE)
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 67 | // Microsoft Visual Studio 2003 and not WinCE.
|
| 68 | #define TIXML_VSCPRINTF _vscprintf // VS2003's C runtime has this, but VC6 C runtime or WinCE SDK doesn't have.
|
| 69 | #else
|
| 70 | // Microsoft Visual Studio 2003 and earlier or WinCE.
|
PKEuS | cac7578 | 2015-08-15 18:17:27 +0200 | [diff] [blame] | 71 | static inline int TIXML_VSCPRINTF( const char* format, va_list va )
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 72 | {
|
| 73 | int len = 512;
|
| 74 | for (;;) {
|
| 75 | len = len*2;
|
| 76 | char* str = new char[len]();
|
| 77 | const int required = _vsnprintf(str, len, format, va);
|
| 78 | delete[] str;
|
| 79 | if ( required != -1 ) {
|
Dmitry-Me | 1d32e58 | 2015-07-27 17:11:51 +0300 | [diff] [blame] | 80 | TIXMLASSERT( required >= 0 );
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 81 | len = required;
|
| 82 | break;
|
| 83 | }
|
| 84 | }
|
Dmitry-Me | 1d32e58 | 2015-07-27 17:11:51 +0300 | [diff] [blame] | 85 | TIXMLASSERT( len >= 0 );
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 86 | return len;
|
| 87 | }
|
| 88 | #endif
|
| 89 | #else
|
| 90 | // GCC version 3 and higher
|
| 91 | //#warning( "Using sn* functions." )
|
| 92 | #define TIXML_SNPRINTF snprintf
|
| 93 | #define TIXML_VSNPRINTF vsnprintf
|
PKEuS | cac7578 | 2015-08-15 18:17:27 +0200 | [diff] [blame] | 94 | static inline int TIXML_VSCPRINTF( const char* format, va_list va )
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 95 | {
|
| 96 | int len = vsnprintf( 0, 0, format, va );
|
Dmitry-Me | 1d32e58 | 2015-07-27 17:11:51 +0300 | [diff] [blame] | 97 | TIXMLASSERT( len >= 0 );
|
Lee Thomason | 53db4a6 | 2015-06-11 22:52:08 -0700 | [diff] [blame] | 98 | return len;
|
| 99 | }
|
| 100 | #define TIXML_SSCANF sscanf
|
| 101 | #endif
|
| 102 |
|
| 103 |
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 104 | static const char LINE_FEED = static_cast<char>(0x0a); // all line endings are normalized to LF
|
Lee Thomason | fde6a75 | 2012-01-14 18:08:12 -0800 | [diff] [blame] | 105 | static const char LF = LINE_FEED;
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 106 | static const char CARRIAGE_RETURN = static_cast<char>(0x0d); // CR gets filtered out
|
Lee Thomason | fde6a75 | 2012-01-14 18:08:12 -0800 | [diff] [blame] | 107 | static const char CR = CARRIAGE_RETURN;
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 108 | static const char SINGLE_QUOTE = '\'';
|
| 109 | static const char DOUBLE_QUOTE = '\"';
|
Lee Thomason | fde6a75 | 2012-01-14 18:08:12 -0800 | [diff] [blame] | 110 |
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 111 | // Bunch of unicode info at:
|
| 112 | // http://www.unicode.org/faq/utf_bom.html
|
| 113 | // ef bb bf (Microsoft "lead bytes") - designates UTF-8
|
| 114 |
|
| 115 | static const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
|
| 116 | static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
|
| 117 | static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 118 |
|
Kevin Wojniak | 04c22d2 | 2012-11-08 11:02:22 -0800 | [diff] [blame] | 119 | namespace tinyxml2
|
| 120 | {
|
| 121 |
|
Lee Thomason | 8ee7989 | 2012-01-25 17:44:30 -0800 | [diff] [blame] | 122 | struct Entity {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 123 | const char* pattern;
|
| 124 | int length;
|
| 125 | char value;
|
Lee Thomason | 8ee7989 | 2012-01-25 17:44:30 -0800 | [diff] [blame] | 126 | };
|
| 127 |
|
| 128 | static const int NUM_ENTITIES = 5;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 129 | static const Entity entities[NUM_ENTITIES] = {
|
| 130 | { "quot", 4, DOUBLE_QUOTE },
|
| 131 | { "amp", 3, '&' },
|
| 132 | { "apos", 4, SINGLE_QUOTE },
|
| 133 | { "lt", 2, '<' },
|
| 134 | { "gt", 2, '>' }
|
Lee Thomason | 8ee7989 | 2012-01-25 17:44:30 -0800 | [diff] [blame] | 135 | };
|
| 136 |
|
Lee Thomason | fde6a75 | 2012-01-14 18:08:12 -0800 | [diff] [blame] | 137 |
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 138 | StrPair::~StrPair()
|
| 139 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 140 | Reset();
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 141 | }
|
| 142 |
|
| 143 |
|
Lee Thomason | 2965880 | 2014-11-27 22:31:11 -0800 | [diff] [blame] | 144 | void StrPair::TransferTo( StrPair* other )
|
Dmitry-Me | 08b40dd | 2014-11-10 11:17:21 +0300 | [diff] [blame] | 145 | {
|
Lee Thomason | 2965880 | 2014-11-27 22:31:11 -0800 | [diff] [blame] | 146 | if ( this == other ) {
|
Dmitry-Me | 08b40dd | 2014-11-10 11:17:21 +0300 | [diff] [blame] | 147 | return;
|
| 148 | }
|
| 149 | // This in effect implements the assignment operator by "moving"
|
| 150 | // ownership (as in auto_ptr).
|
| 151 |
|
Dmitry-Me | db02b21 | 2016-08-04 17:16:05 +0300 | [diff] [blame] | 152 | TIXMLASSERT( other != 0 );
|
Lee Thomason | 2965880 | 2014-11-27 22:31:11 -0800 | [diff] [blame] | 153 | TIXMLASSERT( other->_flags == 0 );
|
| 154 | TIXMLASSERT( other->_start == 0 );
|
| 155 | TIXMLASSERT( other->_end == 0 );
|
Dmitry-Me | 08b40dd | 2014-11-10 11:17:21 +0300 | [diff] [blame] | 156 |
|
Lee Thomason | 2965880 | 2014-11-27 22:31:11 -0800 | [diff] [blame] | 157 | other->Reset();
|
Dmitry-Me | 08b40dd | 2014-11-10 11:17:21 +0300 | [diff] [blame] | 158 |
|
Lee Thomason | 2965880 | 2014-11-27 22:31:11 -0800 | [diff] [blame] | 159 | other->_flags = _flags;
|
| 160 | other->_start = _start;
|
| 161 | other->_end = _end;
|
Dmitry-Me | 08b40dd | 2014-11-10 11:17:21 +0300 | [diff] [blame] | 162 |
|
| 163 | _flags = 0;
|
| 164 | _start = 0;
|
| 165 | _end = 0;
|
| 166 | }
|
| 167 |
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 168 |
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 169 | void StrPair::Reset()
|
| 170 | {
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 171 | if ( _flags & NEEDS_DELETE ) {
|
| 172 | delete [] _start;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 173 | }
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 174 | _flags = 0;
|
| 175 | _start = 0;
|
| 176 | _end = 0;
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 177 | }
|
| 178 |
|
| 179 |
|
| 180 | void StrPair::SetStr( const char* str, int flags )
|
| 181 | {
|
Dmitry-Me | 0515fa9 | 2015-12-09 11:54:06 +0300 | [diff] [blame] | 182 | TIXMLASSERT( str );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 183 | Reset();
|
| 184 | size_t len = strlen( str );
|
Dmitry-Me | 96f38cc | 2015-08-10 16:45:12 +0300 | [diff] [blame] | 185 | TIXMLASSERT( _start == 0 );
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 186 | _start = new char[ len+1 ];
|
| 187 | memcpy( _start, str, len+1 );
|
| 188 | _end = _start + len;
|
| 189 | _flags = flags | NEEDS_DELETE;
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 190 | }
|
| 191 |
|
| 192 |
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 193 | char* StrPair::ParseText( char* p, const char* endTag, int strFlags, int* curLineNumPtr )
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 194 | {
|
Dmitry-Me | f9f3c3e | 2016-08-30 15:51:55 +0300 | [diff] [blame] | 195 | TIXMLASSERT( p );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 196 | TIXMLASSERT( endTag && *endTag );
|
Lee Thomason | e90e901 | 2016-12-24 07:34:39 -0800 | [diff] [blame] | 197 | TIXMLASSERT(curLineNumPtr);
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 198 |
|
Dmitry-Me | ec19a0e | 2014-08-25 11:05:55 +0400 | [diff] [blame] | 199 | char* start = p;
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 200 | const char endChar = *endTag;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 201 | size_t length = strlen( endTag );
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 202 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 203 | // Inner loop of text parsing.
|
| 204 | while ( *p ) {
|
| 205 | if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
|
| 206 | Set( start, p, strFlags );
|
| 207 | return p + length;
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 208 | } else if (*p == '\n') {
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 209 | ++(*curLineNumPtr);
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 210 | }
|
| 211 | ++p;
|
Dmitry-Me | f9f3c3e | 2016-08-30 15:51:55 +0300 | [diff] [blame] | 212 | TIXMLASSERT( p );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 213 | }
|
| 214 | return 0;
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 215 | }
|
| 216 |
|
| 217 |
|
| 218 | char* StrPair::ParseName( char* p )
|
| 219 | {
|
Dmitry-Me | 9fb2b0f | 2014-09-23 17:27:39 +0400 | [diff] [blame] | 220 | if ( !p || !(*p) ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 221 | return 0;
|
| 222 | }
|
JayXon | ee525db | 2014-12-24 04:01:42 -0500 | [diff] [blame] | 223 | if ( !XMLUtil::IsNameStartChar( *p ) ) {
|
| 224 | return 0;
|
| 225 | }
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 226 |
|
Dmitry-Me | 9fb2b0f | 2014-09-23 17:27:39 +0400 | [diff] [blame] | 227 | char* const start = p;
|
JayXon | ee525db | 2014-12-24 04:01:42 -0500 | [diff] [blame] | 228 | ++p;
|
| 229 | while ( *p && XMLUtil::IsNameChar( *p ) ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 230 | ++p;
|
| 231 | }
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 232 |
|
JayXon | ee525db | 2014-12-24 04:01:42 -0500 | [diff] [blame] | 233 | Set( start, p, 0 );
|
| 234 | return p;
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 235 | }
|
| 236 |
|
| 237 |
|
Lee Thomason (grinliz) | bc1bfb7 | 2012-08-20 22:00:38 -0700 | [diff] [blame] | 238 | void StrPair::CollapseWhitespace()
|
| 239 | {
|
Dmitry-Me | 67a5bb0 | 2014-08-20 10:01:53 +0400 | [diff] [blame] | 240 | // Adjusting _start would cause undefined behavior on delete[]
|
| 241 | TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 242 | // Trim leading space.
|
Lee Thomason | e90e901 | 2016-12-24 07:34:39 -0800 | [diff] [blame] | 243 | _start = XMLUtil::SkipWhiteSpace( _start, 0 );
|
Lee Thomason (grinliz) | bc1bfb7 | 2012-08-20 22:00:38 -0700 | [diff] [blame] | 244 |
|
Dmitry-Me | bb836dc | 2014-12-24 11:54:05 +0300 | [diff] [blame] | 245 | if ( *_start ) {
|
Dmitry-Me | 2449582 | 2016-09-02 16:53:32 +0300 | [diff] [blame] | 246 | const char* p = _start; // the read pointer
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 247 | char* q = _start; // the write pointer
|
Lee Thomason (grinliz) | bc1bfb7 | 2012-08-20 22:00:38 -0700 | [diff] [blame] | 248 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 249 | while( *p ) {
|
| 250 | if ( XMLUtil::IsWhiteSpace( *p )) {
|
Lee Thomason | e90e901 | 2016-12-24 07:34:39 -0800 | [diff] [blame] | 251 | p = XMLUtil::SkipWhiteSpace( p, 0 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 252 | if ( *p == 0 ) {
|
| 253 | break; // don't write to q; this trims the trailing space.
|
| 254 | }
|
| 255 | *q = ' ';
|
| 256 | ++q;
|
| 257 | }
|
| 258 | *q = *p;
|
| 259 | ++q;
|
| 260 | ++p;
|
| 261 | }
|
| 262 | *q = 0;
|
| 263 | }
|
Lee Thomason (grinliz) | bc1bfb7 | 2012-08-20 22:00:38 -0700 | [diff] [blame] | 264 | }
|
| 265 |
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 266 |
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 267 | const char* StrPair::GetStr()
|
| 268 | {
|
Dmitry-Me | 5ffa73e | 2015-01-01 17:47:40 +0300 | [diff] [blame] | 269 | TIXMLASSERT( _start );
|
| 270 | TIXMLASSERT( _end );
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 271 | if ( _flags & NEEDS_FLUSH ) {
|
| 272 | *_end = 0;
|
| 273 | _flags ^= NEEDS_FLUSH;
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 274 |
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 275 | if ( _flags ) {
|
Dmitry-Me | 2449582 | 2016-09-02 16:53:32 +0300 | [diff] [blame] | 276 | const char* p = _start; // the read pointer
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 277 | char* q = _start; // the write pointer
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 278 |
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 279 | while( p < _end ) {
|
| 280 | if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 281 | // CR-LF pair becomes LF
|
| 282 | // CR alone becomes LF
|
| 283 | // LF-CR becomes LF
|
| 284 | if ( *(p+1) == LF ) {
|
| 285 | p += 2;
|
| 286 | }
|
| 287 | else {
|
| 288 | ++p;
|
| 289 | }
|
Dmitry-Me | fed5112 | 2016-09-06 18:08:55 +0300 | [diff] [blame] | 290 | *q = LF;
|
| 291 | ++q;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 292 | }
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 293 | else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 294 | if ( *(p+1) == CR ) {
|
| 295 | p += 2;
|
| 296 | }
|
| 297 | else {
|
| 298 | ++p;
|
| 299 | }
|
Dmitry-Me | fed5112 | 2016-09-06 18:08:55 +0300 | [diff] [blame] | 300 | *q = LF;
|
| 301 | ++q;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 302 | }
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 303 | else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 304 | // Entities handled by tinyXML2:
|
| 305 | // - special entities in the entity table [in/out]
|
| 306 | // - numeric character reference [in]
|
| 307 | // 中 or 中
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 308 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 309 | if ( *(p+1) == '#' ) {
|
Dmitry-Me | 63f3de1 | 2014-08-21 12:33:19 +0400 | [diff] [blame] | 310 | const int buflen = 10;
|
| 311 | char buf[buflen] = { 0 };
|
| 312 | int len = 0;
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 313 | const char* adjusted = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
|
Dmitry-Me | 6f51c80 | 2015-03-14 13:25:03 +0300 | [diff] [blame] | 314 | if ( adjusted == 0 ) {
|
| 315 | *q = *p;
|
| 316 | ++p;
|
| 317 | ++q;
|
| 318 | }
|
| 319 | else {
|
| 320 | TIXMLASSERT( 0 <= len && len <= buflen );
|
| 321 | TIXMLASSERT( q + len <= adjusted );
|
| 322 | p = adjusted;
|
| 323 | memcpy( q, buf, len );
|
| 324 | q += len;
|
| 325 | }
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 326 | }
|
| 327 | else {
|
Dmitry-Me | 764545e | 2015-05-20 10:29:24 +0300 | [diff] [blame] | 328 | bool entityFound = false;
|
| 329 | for( int i = 0; i < NUM_ENTITIES; ++i ) {
|
Dmitry-Me | d048f1e | 2014-10-01 10:30:16 +0400 | [diff] [blame] | 330 | const Entity& entity = entities[i];
|
| 331 | if ( strncmp( p + 1, entity.pattern, entity.length ) == 0
|
| 332 | && *( p + entity.length + 1 ) == ';' ) {
|
| 333 | // Found an entity - convert.
|
| 334 | *q = entity.value;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 335 | ++q;
|
Dmitry-Me | d048f1e | 2014-10-01 10:30:16 +0400 | [diff] [blame] | 336 | p += entity.length + 2;
|
Dmitry-Me | 764545e | 2015-05-20 10:29:24 +0300 | [diff] [blame] | 337 | entityFound = true;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 338 | break;
|
| 339 | }
|
| 340 | }
|
Dmitry-Me | 764545e | 2015-05-20 10:29:24 +0300 | [diff] [blame] | 341 | if ( !entityFound ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 342 | // fixme: treat as error?
|
| 343 | ++p;
|
| 344 | ++q;
|
| 345 | }
|
| 346 | }
|
| 347 | }
|
| 348 | else {
|
| 349 | *q = *p;
|
| 350 | ++p;
|
| 351 | ++q;
|
| 352 | }
|
| 353 | }
|
| 354 | *q = 0;
|
| 355 | }
|
| 356 | // The loop below has plenty going on, and this
|
| 357 | // is a less useful mode. Break it out.
|
Dmitry-Me | 5420e54 | 2015-05-20 10:51:26 +0300 | [diff] [blame] | 358 | if ( _flags & NEEDS_WHITESPACE_COLLAPSING ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 359 | CollapseWhitespace();
|
| 360 | }
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 361 | _flags = (_flags & NEEDS_DELETE);
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 362 | }
|
Dmitry-Me | 5ffa73e | 2015-01-01 17:47:40 +0300 | [diff] [blame] | 363 | TIXMLASSERT( _start );
|
Lee Thomason | 120b3a6 | 2012-10-12 10:06:59 -0700 | [diff] [blame] | 364 | return _start;
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 365 | }
|
| 366 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame] | 367 |
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 368 |
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 369 |
|
Lee Thomason | 56bdd02 | 2012-02-09 18:16:58 -0800 | [diff] [blame] | 370 | // --------- XMLUtil ----------- //
|
Lee Thomason | d198322 | 2012-02-06 08:41:24 -0800 | [diff] [blame] | 371 |
|
Lee Thomason | f458d26 | 2016-12-26 22:47:25 -0800 | [diff] [blame] | 372 | const char* XMLUtil::writeBoolTrue = "true";
|
| 373 | const char* XMLUtil::writeBoolFalse = "false";
|
Lee Thomason | ce667c9 | 2016-12-26 16:45:30 -0800 | [diff] [blame] | 374 |
|
Lee Thomason | c5c99c2 | 2016-12-29 11:19:17 -0800 | [diff] [blame] | 375 | void XMLUtil::SetBoolSerialization(const char* writeTrue, const char* writeFalse)
|
Lee Thomason | ce667c9 | 2016-12-26 16:45:30 -0800 | [diff] [blame] | 376 | {
|
Lee Thomason | c5c99c2 | 2016-12-29 11:19:17 -0800 | [diff] [blame] | 377 | static const char* defTrue = "true";
|
Lee Thomason | ce667c9 | 2016-12-26 16:45:30 -0800 | [diff] [blame] | 378 | static const char* defFalse = "false";
|
Lee Thomason | ce667c9 | 2016-12-26 16:45:30 -0800 | [diff] [blame] | 379 |
|
Lee Thomason | c5c99c2 | 2016-12-29 11:19:17 -0800 | [diff] [blame] | 380 | writeBoolTrue = (writeTrue) ? writeTrue : defTrue;
|
| 381 | writeBoolFalse = (writeFalse) ? writeFalse : defFalse;
|
Lee Thomason | ce667c9 | 2016-12-26 16:45:30 -0800 | [diff] [blame] | 382 | }
|
| 383 |
|
| 384 |
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 385 | const char* XMLUtil::ReadBOM( const char* p, bool* bom )
|
| 386 | {
|
Dmitry-Me | bb836dc | 2014-12-24 11:54:05 +0300 | [diff] [blame] | 387 | TIXMLASSERT( p );
|
| 388 | TIXMLASSERT( bom );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 389 | *bom = false;
|
| 390 | const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);
|
| 391 | // Check for BOM:
|
| 392 | if ( *(pu+0) == TIXML_UTF_LEAD_0
|
| 393 | && *(pu+1) == TIXML_UTF_LEAD_1
|
| 394 | && *(pu+2) == TIXML_UTF_LEAD_2 ) {
|
| 395 | *bom = true;
|
| 396 | p += 3;
|
| 397 | }
|
Dmitry-Me | bb836dc | 2014-12-24 11:54:05 +0300 | [diff] [blame] | 398 | TIXMLASSERT( p );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 399 | return p;
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 400 | }
|
| 401 |
|
| 402 |
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 403 | void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
|
| 404 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 405 | const unsigned long BYTE_MASK = 0xBF;
|
| 406 | const unsigned long BYTE_MARK = 0x80;
|
| 407 | const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 408 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 409 | if (input < 0x80) {
|
| 410 | *length = 1;
|
| 411 | }
|
| 412 | else if ( input < 0x800 ) {
|
| 413 | *length = 2;
|
| 414 | }
|
| 415 | else if ( input < 0x10000 ) {
|
| 416 | *length = 3;
|
| 417 | }
|
| 418 | else if ( input < 0x200000 ) {
|
| 419 | *length = 4;
|
| 420 | }
|
| 421 | else {
|
Dmitry-Me | 2f465c4 | 2015-03-16 11:08:23 +0300 | [diff] [blame] | 422 | *length = 0; // This code won't convert this correctly anyway.
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 423 | return;
|
| 424 | }
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 425 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 426 | output += *length;
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 427 |
|
Dmitry-Me | 3cc6f5c | 2017-08-03 18:42:20 +0300 | [diff] [blame] | 428 | // Scary scary fall throughs are annotated with carefully designed comments
|
| 429 | // to suppress compiler warnings such as -Wimplicit-fallthrough in gcc
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 430 | switch (*length) {
|
| 431 | case 4:
|
| 432 | --output;
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 433 | *output = static_cast<char>((input | BYTE_MARK) & BYTE_MASK);
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 434 | input >>= 6;
|
Dmitry-Me | 3cc6f5c | 2017-08-03 18:42:20 +0300 | [diff] [blame] | 435 | //fall through
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 436 | case 3:
|
| 437 | --output;
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 438 | *output = static_cast<char>((input | BYTE_MARK) & BYTE_MASK);
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 439 | input >>= 6;
|
Dmitry-Me | 3cc6f5c | 2017-08-03 18:42:20 +0300 | [diff] [blame] | 440 | //fall through
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 441 | case 2:
|
| 442 | --output;
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 443 | *output = static_cast<char>((input | BYTE_MARK) & BYTE_MASK);
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 444 | input >>= 6;
|
Dmitry-Me | 3cc6f5c | 2017-08-03 18:42:20 +0300 | [diff] [blame] | 445 | //fall through
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 446 | case 1:
|
| 447 | --output;
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 448 | *output = static_cast<char>(input | FIRST_BYTE_MARK[*length]);
|
MortenMacFly | 4ee49f1 | 2013-01-14 20:03:14 +0100 | [diff] [blame] | 449 | break;
|
Dmitry-Me | 33bb764 | 2015-03-14 17:14:00 +0300 | [diff] [blame] | 450 | default:
|
| 451 | TIXMLASSERT( false );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 452 | }
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 453 | }
|
| 454 |
|
| 455 |
|
| 456 | const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )
|
| 457 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 458 | // Presume an entity, and pull it out.
|
| 459 | *length = 0;
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 460 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 461 | if ( *(p+1) == '#' && *(p+2) ) {
|
| 462 | unsigned long ucs = 0;
|
Dmitry-Me | bbaf1e1 | 2015-01-12 14:07:10 +0300 | [diff] [blame] | 463 | TIXMLASSERT( sizeof( ucs ) >= 4 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 464 | ptrdiff_t delta = 0;
|
| 465 | unsigned mult = 1;
|
Lee Thomason | 7e67bc8 | 2015-01-12 14:05:12 -0800 | [diff] [blame] | 466 | static const char SEMICOLON = ';';
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 467 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 468 | if ( *(p+2) == 'x' ) {
|
| 469 | // Hexadecimal.
|
Dmitry-Me | 6acc9a5 | 2015-01-15 13:27:47 +0300 | [diff] [blame] | 470 | const char* q = p+3;
|
| 471 | if ( !(*q) ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 472 | return 0;
|
| 473 | }
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 474 |
|
Lee Thomason | 7e67bc8 | 2015-01-12 14:05:12 -0800 | [diff] [blame] | 475 | q = strchr( q, SEMICOLON );
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 476 |
|
Dmitry-Me | 9f56e12 | 2015-01-12 10:07:54 +0300 | [diff] [blame] | 477 | if ( !q ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 478 | return 0;
|
| 479 | }
|
Lee Thomason | 7e67bc8 | 2015-01-12 14:05:12 -0800 | [diff] [blame] | 480 | TIXMLASSERT( *q == SEMICOLON );
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 481 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 482 | delta = q-p;
|
| 483 | --q;
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 484 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 485 | while ( *q != 'x' ) {
|
Lee Thomason | 7265b76 | 2015-03-15 16:11:47 -0700 | [diff] [blame] | 486 | unsigned int digit = 0;
|
| 487 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 488 | if ( *q >= '0' && *q <= '9' ) {
|
Dmitry-Me | bab9b6d | 2015-03-14 16:41:46 +0300 | [diff] [blame] | 489 | digit = *q - '0';
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 490 | }
|
| 491 | else if ( *q >= 'a' && *q <= 'f' ) {
|
Dmitry-Me | bab9b6d | 2015-03-14 16:41:46 +0300 | [diff] [blame] | 492 | digit = *q - 'a' + 10;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 493 | }
|
| 494 | else if ( *q >= 'A' && *q <= 'F' ) {
|
Dmitry-Me | bab9b6d | 2015-03-14 16:41:46 +0300 | [diff] [blame] | 495 | digit = *q - 'A' + 10;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 496 | }
|
| 497 | else {
|
| 498 | return 0;
|
| 499 | }
|
Wilfred van Velzen | 0aeac18 | 2016-03-25 14:14:03 +0100 | [diff] [blame] | 500 | TIXMLASSERT( digit < 16 );
|
Dmitry-Me | bab9b6d | 2015-03-14 16:41:46 +0300 | [diff] [blame] | 501 | TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );
|
| 502 | const unsigned int digitScaled = mult * digit;
|
| 503 | TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
|
| 504 | ucs += digitScaled;
|
Dmitry-Me | bbaf1e1 | 2015-01-12 14:07:10 +0300 | [diff] [blame] | 505 | TIXMLASSERT( mult <= UINT_MAX / 16 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 506 | mult *= 16;
|
| 507 | --q;
|
| 508 | }
|
| 509 | }
|
| 510 | else {
|
| 511 | // Decimal.
|
Dmitry-Me | 6acc9a5 | 2015-01-15 13:27:47 +0300 | [diff] [blame] | 512 | const char* q = p+2;
|
| 513 | if ( !(*q) ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 514 | return 0;
|
| 515 | }
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 516 |
|
Lee Thomason | 7e67bc8 | 2015-01-12 14:05:12 -0800 | [diff] [blame] | 517 | q = strchr( q, SEMICOLON );
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 518 |
|
Dmitry-Me | 9f56e12 | 2015-01-12 10:07:54 +0300 | [diff] [blame] | 519 | if ( !q ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 520 | return 0;
|
| 521 | }
|
Lee Thomason | 7e67bc8 | 2015-01-12 14:05:12 -0800 | [diff] [blame] | 522 | TIXMLASSERT( *q == SEMICOLON );
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 523 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 524 | delta = q-p;
|
| 525 | --q;
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 526 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 527 | while ( *q != '#' ) {
|
| 528 | if ( *q >= '0' && *q <= '9' ) {
|
Dmitry-Me | bab9b6d | 2015-03-14 16:41:46 +0300 | [diff] [blame] | 529 | const unsigned int digit = *q - '0';
|
Wilfred van Velzen | 0aeac18 | 2016-03-25 14:14:03 +0100 | [diff] [blame] | 530 | TIXMLASSERT( digit < 10 );
|
Dmitry-Me | bab9b6d | 2015-03-14 16:41:46 +0300 | [diff] [blame] | 531 | TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );
|
| 532 | const unsigned int digitScaled = mult * digit;
|
| 533 | TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
|
| 534 | ucs += digitScaled;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 535 | }
|
| 536 | else {
|
| 537 | return 0;
|
| 538 | }
|
Dmitry-Me | bbaf1e1 | 2015-01-12 14:07:10 +0300 | [diff] [blame] | 539 | TIXMLASSERT( mult <= UINT_MAX / 10 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 540 | mult *= 10;
|
| 541 | --q;
|
| 542 | }
|
| 543 | }
|
| 544 | // convert the UCS to UTF-8
|
| 545 | ConvertUTF32ToUTF8( ucs, value, length );
|
| 546 | return p + delta + 1;
|
| 547 | }
|
| 548 | return p+1;
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 549 | }
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 550 |
|
| 551 |
|
Lee Thomason (grinliz) | 2f1f624 | 2012-09-16 11:32:34 -0700 | [diff] [blame] | 552 | void XMLUtil::ToStr( int v, char* buffer, int bufferSize )
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 553 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 554 | TIXML_SNPRINTF( buffer, bufferSize, "%d", v );
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 555 | }
|
| 556 |
|
| 557 |
|
| 558 | void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )
|
| 559 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 560 | TIXML_SNPRINTF( buffer, bufferSize, "%u", v );
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 561 | }
|
| 562 |
|
| 563 |
|
| 564 | void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
|
| 565 | {
|
Lee Thomason | ce667c9 | 2016-12-26 16:45:30 -0800 | [diff] [blame] | 566 | TIXML_SNPRINTF( buffer, bufferSize, "%s", v ? writeBoolTrue : writeBoolFalse);
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 567 | }
|
| 568 |
|
Lee Thomason | c3708cc | 2014-01-14 12:30:03 -0800 | [diff] [blame] | 569 | /*
|
| 570 | ToStr() of a number is a very tricky topic.
|
| 571 | https://github.com/leethomason/tinyxml2/issues/106
|
| 572 | */
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 573 | void XMLUtil::ToStr( float v, char* buffer, int bufferSize )
|
| 574 | {
|
Lee Thomason | c3708cc | 2014-01-14 12:30:03 -0800 | [diff] [blame] | 575 | TIXML_SNPRINTF( buffer, bufferSize, "%.8g", v );
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 576 | }
|
| 577 |
|
| 578 |
|
| 579 | void XMLUtil::ToStr( double v, char* buffer, int bufferSize )
|
| 580 | {
|
Lee Thomason | c3708cc | 2014-01-14 12:30:03 -0800 | [diff] [blame] | 581 | TIXML_SNPRINTF( buffer, bufferSize, "%.17g", v );
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 582 | }
|
| 583 |
|
| 584 |
|
cugone | 47e229e | 2019-04-12 17:27:28 -0500 | [diff] [blame] | 585 | void XMLUtil::ToStr( int64_t v, char* buffer, int bufferSize )
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 586 | {
|
Lee Thomason | 5bf60e9 | 2016-07-17 22:49:40 -0700 | [diff] [blame] | 587 | // horrible syntax trick to make the compiler happy about %lld
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 588 | TIXML_SNPRINTF(buffer, bufferSize, "%lld", static_cast<long long>(v));
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 589 | }
|
| 590 |
|
cugone | 47e229e | 2019-04-12 17:27:28 -0500 | [diff] [blame] | 591 | void XMLUtil::ToStr( uint64_t v, char* buffer, int bufferSize )
|
| 592 | {
|
| 593 | // horrible syntax trick to make the compiler happy about %llu
|
| 594 | TIXML_SNPRINTF(buffer, bufferSize, "%llu", (long long)v);
|
| 595 | }
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 596 |
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 597 | bool XMLUtil::ToInt( const char* str, int* value )
|
| 598 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 599 | if ( TIXML_SSCANF( str, "%d", value ) == 1 ) {
|
| 600 | return true;
|
| 601 | }
|
| 602 | return false;
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 603 | }
|
| 604 |
|
| 605 | bool XMLUtil::ToUnsigned( const char* str, unsigned *value )
|
| 606 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 607 | if ( TIXML_SSCANF( str, "%u", value ) == 1 ) {
|
| 608 | return true;
|
| 609 | }
|
| 610 | return false;
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 611 | }
|
| 612 |
|
| 613 | bool XMLUtil::ToBool( const char* str, bool* value )
|
| 614 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 615 | int ival = 0;
|
| 616 | if ( ToInt( str, &ival )) {
|
| 617 | *value = (ival==0) ? false : true;
|
| 618 | return true;
|
| 619 | }
|
Dan Nissenbaum | d745503 | 2019-10-24 23:57:45 -0400 | [diff] [blame] | 620 | static const char* TRUE_VALS[] = { "true", "True", "TRUE", 0 };
|
| 621 | static const char* FALSE_VALS[] = { "false", "False", "FALSE", 0 };
|
Lee Thomason | 7fd646a | 2019-08-10 17:40:19 -0700 | [diff] [blame] | 622 |
|
Dan Nissenbaum | d745503 | 2019-10-24 23:57:45 -0400 | [diff] [blame] | 623 | for (int i = 0; TRUE_VALS[i]; ++i) {
|
| 624 | if (StringEqual(str, TRUE_VALS[i])) {
|
Lee Thomason | 7fd646a | 2019-08-10 17:40:19 -0700 | [diff] [blame] | 625 | *value = true;
|
| 626 | return true;
|
| 627 | }
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 628 | }
|
Dan Nissenbaum | d745503 | 2019-10-24 23:57:45 -0400 | [diff] [blame] | 629 | for (int i = 0; FALSE_VALS[i]; ++i) {
|
| 630 | if (StringEqual(str, FALSE_VALS[i])) {
|
Lee Thomason | 7fd646a | 2019-08-10 17:40:19 -0700 | [diff] [blame] | 631 | *value = false;
|
| 632 | return true;
|
| 633 | }
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 634 | }
|
| 635 | return false;
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 636 | }
|
| 637 |
|
| 638 |
|
| 639 | bool XMLUtil::ToFloat( const char* str, float* value )
|
| 640 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 641 | if ( TIXML_SSCANF( str, "%f", value ) == 1 ) {
|
| 642 | return true;
|
| 643 | }
|
| 644 | return false;
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 645 | }
|
| 646 |
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 647 |
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 648 | bool XMLUtil::ToDouble( const char* str, double* value )
|
| 649 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 650 | if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) {
|
| 651 | return true;
|
| 652 | }
|
| 653 | return false;
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 654 | }
|
| 655 |
|
| 656 |
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 657 | bool XMLUtil::ToInt64(const char* str, int64_t* value)
|
| 658 | {
|
Lee Thomason | 5bf60e9 | 2016-07-17 22:49:40 -0700 | [diff] [blame] | 659 | long long v = 0; // horrible syntax trick to make the compiler happy about %lld
|
| 660 | if (TIXML_SSCANF(str, "%lld", &v) == 1) {
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 661 | *value = static_cast<int64_t>(v);
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 662 | return true;
|
| 663 | }
|
| 664 | return false;
|
| 665 | }
|
| 666 |
|
| 667 |
|
cugone | 75a5acc | 2019-04-11 22:03:43 -0500 | [diff] [blame] | 668 | bool XMLUtil::ToUnsigned64(const char* str, uint64_t* value) {
|
| 669 | unsigned long long v = 0; // horrible syntax trick to make the compiler happy about %llu
|
| 670 | if(TIXML_SSCANF(str, "%llu", &v) == 1) {
|
| 671 | *value = (uint64_t)v;
|
| 672 | return true;
|
| 673 | }
|
| 674 | return false;
|
| 675 | }
|
| 676 |
|
| 677 |
|
Lee Thomason (grinliz) | 2f1f624 | 2012-09-16 11:32:34 -0700 | [diff] [blame] | 678 | char* XMLDocument::Identify( char* p, XMLNode** node )
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 679 | {
|
Dmitry-Me | 0238466 | 2015-03-03 16:02:13 +0300 | [diff] [blame] | 680 | TIXMLASSERT( node );
|
| 681 | TIXMLASSERT( p );
|
Dmitry-Me | 9fb2b0f | 2014-09-23 17:27:39 +0400 | [diff] [blame] | 682 | char* const start = p;
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 683 | int const startLine = _parseCurLineNum;
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 684 | p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
|
Dmitry-Me | bb836dc | 2014-12-24 11:54:05 +0300 | [diff] [blame] | 685 | if( !*p ) {
|
Dmitry-Me | 9fcb876 | 2015-03-05 17:53:34 +0300 | [diff] [blame] | 686 | *node = 0;
|
| 687 | TIXMLASSERT( p );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 688 | return p;
|
| 689 | }
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 690 |
|
Dmitry-Me | 962083b | 2015-05-26 11:38:30 +0300 | [diff] [blame] | 691 | // These strings define the matching patterns:
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 692 | static const char* xmlHeader = { "<?" };
|
| 693 | static const char* commentHeader = { "<!--" };
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 694 | static const char* cdataHeader = { "<![CDATA[" };
|
Dmitry-Me | c505e13 | 2015-03-30 09:54:36 +0300 | [diff] [blame] | 695 | static const char* dtdHeader = { "<!" };
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 696 | static const char* elementHeader = { "<" }; // and a header for everything else; check last.
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 697 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 698 | static const int xmlHeaderLen = 2;
|
| 699 | static const int commentHeaderLen = 4;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 700 | static const int cdataHeaderLen = 9;
|
Dmitry-Me | c505e13 | 2015-03-30 09:54:36 +0300 | [diff] [blame] | 701 | static const int dtdHeaderLen = 2;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 702 | static const int elementHeaderLen = 1;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 703 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 704 | TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) ); // use same memory pool
|
| 705 | TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) ); // use same memory pool
|
Dmitry-Me | 9fb2b0f | 2014-09-23 17:27:39 +0400 | [diff] [blame] | 706 | XMLNode* returnNode = 0;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 707 | if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
|
Dmitry-Me | 2aebfb7 | 2017-02-27 15:53:40 +0300 | [diff] [blame] | 708 | returnNode = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 709 | returnNode->_parseLineNum = _parseCurLineNum;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 710 | p += xmlHeaderLen;
|
| 711 | }
|
| 712 | else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
|
Dmitry-Me | 2aebfb7 | 2017-02-27 15:53:40 +0300 | [diff] [blame] | 713 | returnNode = CreateUnlinkedNode<XMLComment>( _commentPool );
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 714 | returnNode->_parseLineNum = _parseCurLineNum;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 715 | p += commentHeaderLen;
|
| 716 | }
|
| 717 | else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
|
Dmitry-Me | 2aebfb7 | 2017-02-27 15:53:40 +0300 | [diff] [blame] | 718 | XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 719 | returnNode = text;
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 720 | returnNode->_parseLineNum = _parseCurLineNum;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 721 | p += cdataHeaderLen;
|
| 722 | text->SetCData( true );
|
| 723 | }
|
| 724 | else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
|
Dmitry-Me | 2aebfb7 | 2017-02-27 15:53:40 +0300 | [diff] [blame] | 725 | returnNode = CreateUnlinkedNode<XMLUnknown>( _commentPool );
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 726 | returnNode->_parseLineNum = _parseCurLineNum;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 727 | p += dtdHeaderLen;
|
| 728 | }
|
| 729 | else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
|
Dmitry-Me | 2aebfb7 | 2017-02-27 15:53:40 +0300 | [diff] [blame] | 730 | returnNode = CreateUnlinkedNode<XMLElement>( _elementPool );
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 731 | returnNode->_parseLineNum = _parseCurLineNum;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 732 | p += elementHeaderLen;
|
| 733 | }
|
| 734 | else {
|
Dmitry-Me | 2aebfb7 | 2017-02-27 15:53:40 +0300 | [diff] [blame] | 735 | returnNode = CreateUnlinkedNode<XMLText>( _textPool );
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 736 | returnNode->_parseLineNum = _parseCurLineNum; // Report line of first non-whitespace character
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 737 | p = start; // Back it up, all the text counts.
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 738 | _parseCurLineNum = startLine;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 739 | }
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 740 |
|
Dmitry-Me | 0238466 | 2015-03-03 16:02:13 +0300 | [diff] [blame] | 741 | TIXMLASSERT( returnNode );
|
| 742 | TIXMLASSERT( p );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 743 | *node = returnNode;
|
| 744 | return p;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 745 | }
|
| 746 |
|
| 747 |
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 748 | bool XMLDocument::Accept( XMLVisitor* visitor ) const
|
| 749 | {
|
Dmitry-Me | bbaf1e1 | 2015-01-12 14:07:10 +0300 | [diff] [blame] | 750 | TIXMLASSERT( visitor );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 751 | if ( visitor->VisitEnter( *this ) ) {
|
| 752 | for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
|
| 753 | if ( !node->Accept( visitor ) ) {
|
| 754 | break;
|
| 755 | }
|
| 756 | }
|
| 757 | }
|
| 758 | return visitor->VisitExit( *this );
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 759 | }
|
Lee Thomason | 56bdd02 | 2012-02-09 18:16:58 -0800 | [diff] [blame] | 760 |
|
| 761 |
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 762 | // --------- XMLNode ----------- //
|
| 763 |
|
| 764 | XMLNode::XMLNode( XMLDocument* doc ) :
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 765 | _document( doc ),
|
| 766 | _parent( 0 ),
|
Thierry Lelegard | 7f0f754 | 2017-09-01 10:14:16 +0200 | [diff] [blame] | 767 | _value(),
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 768 | _parseLineNum( 0 ),
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 769 | _firstChild( 0 ), _lastChild( 0 ),
|
Thomas Roß | 6189231 | 2013-05-12 14:07:38 +0200 | [diff] [blame] | 770 | _prev( 0 ), _next( 0 ),
|
Lee Thomason | af9bce1 | 2016-07-17 22:35:52 -0700 | [diff] [blame] | 771 | _userData( 0 ),
|
Thomas Roß | 6189231 | 2013-05-12 14:07:38 +0200 | [diff] [blame] | 772 | _memPool( 0 )
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 773 | {
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 774 | }
|
| 775 |
|
| 776 |
|
| 777 | XMLNode::~XMLNode()
|
| 778 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 779 | DeleteChildren();
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 780 | if ( _parent ) {
|
| 781 | _parent->Unlink( this );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 782 | }
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 783 | }
|
| 784 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 785 | const char* XMLNode::Value() const
|
Michael Daumling | 2162688 | 2013-10-22 17:03:37 +0200 | [diff] [blame] | 786 | {
|
Dmitry-Me | caa72a6 | 2016-08-10 17:34:34 +0300 | [diff] [blame] | 787 | // Edge case: XMLDocuments don't have a Value. Return null.
|
Sarat Addepalli | 9c3122b | 2015-05-19 12:49:32 +0530 | [diff] [blame] | 788 | if ( this->ToDocument() )
|
Sarat Addepalli | 96b4346 | 2015-05-20 10:36:06 +0530 | [diff] [blame] | 789 | return 0;
|
Michael Daumling | 2162688 | 2013-10-22 17:03:37 +0200 | [diff] [blame] | 790 | return _value.GetStr();
|
| 791 | }
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 792 |
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 793 | void XMLNode::SetValue( const char* str, bool staticMem )
|
| 794 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 795 | if ( staticMem ) {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 796 | _value.SetInternedStr( str );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 797 | }
|
| 798 | else {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 799 | _value.SetStr( str );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 800 | }
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 801 | }
|
| 802 |
|
Dmitry-Me | 3f63f21 | 2017-06-19 18:25:19 +0300 | [diff] [blame] | 803 | XMLNode* XMLNode::DeepClone(XMLDocument* target) const
|
Lee Thomason | 7085f00 | 2017-06-01 18:09:43 -0700 | [diff] [blame] | 804 | {
|
Dmitry-Me | 3f63f21 | 2017-06-19 18:25:19 +0300 | [diff] [blame] | 805 | XMLNode* clone = this->ShallowClone(target);
|
Lee Thomason | 7085f00 | 2017-06-01 18:09:43 -0700 | [diff] [blame] | 806 | if (!clone) return 0;
|
| 807 |
|
| 808 | for (const XMLNode* child = this->FirstChild(); child; child = child->NextSibling()) {
|
Dmitry-Me | 3f63f21 | 2017-06-19 18:25:19 +0300 | [diff] [blame] | 809 | XMLNode* childClone = child->DeepClone(target);
|
Lee Thomason | 7085f00 | 2017-06-01 18:09:43 -0700 | [diff] [blame] | 810 | TIXMLASSERT(childClone);
|
| 811 | clone->InsertEndChild(childClone);
|
| 812 | }
|
| 813 | return clone;
|
| 814 | }
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 815 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 816 | void XMLNode::DeleteChildren()
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 817 | {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 818 | while( _firstChild ) {
|
Dmitry-Me | 9614f8f | 2015-04-08 10:06:06 +0300 | [diff] [blame] | 819 | TIXMLASSERT( _lastChild );
|
Dmitry-Me | 9cb4eca | 2016-08-18 18:10:59 +0300 | [diff] [blame] | 820 | DeleteChild( _firstChild );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 821 | }
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 822 | _firstChild = _lastChild = 0;
|
Lee Thomason | d923c67 | 2012-01-23 08:44:25 -0800 | [diff] [blame] | 823 | }
|
| 824 |
|
| 825 |
|
| 826 | void XMLNode::Unlink( XMLNode* child )
|
| 827 | {
|
Dmitry-Me | bb836dc | 2014-12-24 11:54:05 +0300 | [diff] [blame] | 828 | TIXMLASSERT( child );
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 829 | TIXMLASSERT( child->_document == _document );
|
Dmitry-Me | 9614f8f | 2015-04-08 10:06:06 +0300 | [diff] [blame] | 830 | TIXMLASSERT( child->_parent == this );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 831 | if ( child == _firstChild ) {
|
| 832 | _firstChild = _firstChild->_next;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 833 | }
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 834 | if ( child == _lastChild ) {
|
| 835 | _lastChild = _lastChild->_prev;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 836 | }
|
Lee Thomason | d923c67 | 2012-01-23 08:44:25 -0800 | [diff] [blame] | 837 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 838 | if ( child->_prev ) {
|
| 839 | child->_prev->_next = child->_next;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 840 | }
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 841 | if ( child->_next ) {
|
| 842 | child->_next->_prev = child->_prev;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 843 | }
|
Lee Thomason | 8a76361 | 2017-06-16 09:30:16 -0700 | [diff] [blame] | 844 | child->_next = 0;
|
| 845 | child->_prev = 0;
|
Lee Thomason | 3b7927e | 2013-10-26 21:50:46 -0700 | [diff] [blame] | 846 | child->_parent = 0;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 847 | }
|
| 848 |
|
| 849 |
|
U-Stream\Lee | ae25a44 | 2012-02-17 17:48:16 -0800 | [diff] [blame] | 850 | void XMLNode::DeleteChild( XMLNode* node )
|
| 851 | {
|
Dmitry-Me | bb836dc | 2014-12-24 11:54:05 +0300 | [diff] [blame] | 852 | TIXMLASSERT( node );
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 853 | TIXMLASSERT( node->_document == _document );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 854 | TIXMLASSERT( node->_parent == this );
|
Jarle Strand | 81abfd6 | 2015-12-27 17:30:04 +0100 | [diff] [blame] | 855 | Unlink( node );
|
Lee Thomason | 816d3fa | 2017-06-05 14:35:55 -0700 | [diff] [blame] | 856 | TIXMLASSERT(node->_prev == 0);
|
| 857 | TIXMLASSERT(node->_next == 0);
|
| 858 | TIXMLASSERT(node->_parent == 0);
|
Dmitry-Me | e3225b1 | 2014-09-03 11:03:11 +0400 | [diff] [blame] | 859 | DeleteNode( node );
|
U-Stream\Lee | ae25a44 | 2012-02-17 17:48:16 -0800 | [diff] [blame] | 860 | }
|
| 861 |
|
| 862 |
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 863 | XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
|
| 864 | {
|
Dmitry-Me | ed2a407 | 2014-12-12 10:38:48 +0300 | [diff] [blame] | 865 | TIXMLASSERT( addThis );
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 866 | if ( addThis->_document != _document ) {
|
| 867 | TIXMLASSERT( false );
|
| 868 | return 0;
|
| 869 | }
|
Lee Thomason | 3cebdc4 | 2015-01-05 17:16:28 -0800 | [diff] [blame] | 870 | InsertChildPreamble( addThis );
|
Lee Thomason | 3b7927e | 2013-10-26 21:50:46 -0700 | [diff] [blame] | 871 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 872 | if ( _lastChild ) {
|
| 873 | TIXMLASSERT( _firstChild );
|
| 874 | TIXMLASSERT( _lastChild->_next == 0 );
|
| 875 | _lastChild->_next = addThis;
|
| 876 | addThis->_prev = _lastChild;
|
| 877 | _lastChild = addThis;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 878 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 879 | addThis->_next = 0;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 880 | }
|
| 881 | else {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 882 | TIXMLASSERT( _firstChild == 0 );
|
| 883 | _firstChild = _lastChild = addThis;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 884 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 885 | addThis->_prev = 0;
|
| 886 | addThis->_next = 0;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 887 | }
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 888 | addThis->_parent = this;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 889 | return addThis;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 890 | }
|
| 891 |
|
| 892 |
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 893 | XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
|
| 894 | {
|
Dmitry-Me | ed2a407 | 2014-12-12 10:38:48 +0300 | [diff] [blame] | 895 | TIXMLASSERT( addThis );
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 896 | if ( addThis->_document != _document ) {
|
| 897 | TIXMLASSERT( false );
|
| 898 | return 0;
|
| 899 | }
|
Lee Thomason | 3cebdc4 | 2015-01-05 17:16:28 -0800 | [diff] [blame] | 900 | InsertChildPreamble( addThis );
|
Lee Thomason | 3b7927e | 2013-10-26 21:50:46 -0700 | [diff] [blame] | 901 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 902 | if ( _firstChild ) {
|
| 903 | TIXMLASSERT( _lastChild );
|
| 904 | TIXMLASSERT( _firstChild->_prev == 0 );
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 905 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 906 | _firstChild->_prev = addThis;
|
| 907 | addThis->_next = _firstChild;
|
| 908 | _firstChild = addThis;
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 909 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 910 | addThis->_prev = 0;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 911 | }
|
| 912 | else {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 913 | TIXMLASSERT( _lastChild == 0 );
|
| 914 | _firstChild = _lastChild = addThis;
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 915 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 916 | addThis->_prev = 0;
|
| 917 | addThis->_next = 0;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 918 | }
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 919 | addThis->_parent = this;
|
Dmitry-Me | 9fb2b0f | 2014-09-23 17:27:39 +0400 | [diff] [blame] | 920 | return addThis;
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 921 | }
|
| 922 |
|
| 923 |
|
| 924 | XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
|
| 925 | {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 926 | TIXMLASSERT( addThis );
|
| 927 | if ( addThis->_document != _document ) {
|
| 928 | TIXMLASSERT( false );
|
| 929 | return 0;
|
| 930 | }
|
Lee Thomason | 3b7927e | 2013-10-26 21:50:46 -0700 | [diff] [blame] | 931 |
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 932 | TIXMLASSERT( afterThis );
|
Lee Thomason | 3b7927e | 2013-10-26 21:50:46 -0700 | [diff] [blame] | 933 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 934 | if ( afterThis->_parent != this ) {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 935 | TIXMLASSERT( false );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 936 | return 0;
|
| 937 | }
|
Dmitry-Me | e8f4a8b | 2017-09-15 19:34:36 +0300 | [diff] [blame] | 938 | if ( afterThis == addThis ) {
|
| 939 | // Current state: BeforeThis -> AddThis -> OneAfterAddThis
|
| 940 | // Now AddThis must disappear from it's location and then
|
| 941 | // reappear between BeforeThis and OneAfterAddThis.
|
| 942 | // So just leave it where it is.
|
| 943 | return addThis;
|
| 944 | }
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 945 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 946 | if ( afterThis->_next == 0 ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 947 | // The last node or the only node.
|
| 948 | return InsertEndChild( addThis );
|
| 949 | }
|
Lee Thomason | 3cebdc4 | 2015-01-05 17:16:28 -0800 | [diff] [blame] | 950 | InsertChildPreamble( addThis );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 951 | addThis->_prev = afterThis;
|
| 952 | addThis->_next = afterThis->_next;
|
| 953 | afterThis->_next->_prev = addThis;
|
| 954 | afterThis->_next = addThis;
|
| 955 | addThis->_parent = this;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 956 | return addThis;
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 957 | }
|
| 958 |
|
| 959 |
|
| 960 |
|
| 961 |
|
Dmitry-Me | 886ad97 | 2015-07-22 11:00:51 +0300 | [diff] [blame] | 962 | const XMLElement* XMLNode::FirstChildElement( const char* name ) const
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame] | 963 | {
|
Dmitry-Me | 2667aab | 2015-04-03 10:56:59 +0300 | [diff] [blame] | 964 | for( const XMLNode* node = _firstChild; node; node = node->_next ) {
|
Dmitry-Me | ecb9b07 | 2016-10-12 16:44:59 +0300 | [diff] [blame] | 965 | const XMLElement* element = node->ToElementWithName( name );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 966 | if ( element ) {
|
Dmitry-Me | ecb9b07 | 2016-10-12 16:44:59 +0300 | [diff] [blame] | 967 | return element;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 968 | }
|
| 969 | }
|
| 970 | return 0;
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame] | 971 | }
|
| 972 |
|
| 973 |
|
Dmitry-Me | 886ad97 | 2015-07-22 11:00:51 +0300 | [diff] [blame] | 974 | const XMLElement* XMLNode::LastChildElement( const char* name ) const
|
Lee Thomason | 56bdd02 | 2012-02-09 18:16:58 -0800 | [diff] [blame] | 975 | {
|
Dmitry-Me | 2667aab | 2015-04-03 10:56:59 +0300 | [diff] [blame] | 976 | for( const XMLNode* node = _lastChild; node; node = node->_prev ) {
|
Dmitry-Me | ecb9b07 | 2016-10-12 16:44:59 +0300 | [diff] [blame] | 977 | const XMLElement* element = node->ToElementWithName( name );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 978 | if ( element ) {
|
Dmitry-Me | ecb9b07 | 2016-10-12 16:44:59 +0300 | [diff] [blame] | 979 | return element;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 980 | }
|
| 981 | }
|
| 982 | return 0;
|
Lee Thomason | 56bdd02 | 2012-02-09 18:16:58 -0800 | [diff] [blame] | 983 | }
|
| 984 |
|
| 985 |
|
Dmitry-Me | 886ad97 | 2015-07-22 11:00:51 +0300 | [diff] [blame] | 986 | const XMLElement* XMLNode::NextSiblingElement( const char* name ) const
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 987 | {
|
Dmitry-Me | 2667aab | 2015-04-03 10:56:59 +0300 | [diff] [blame] | 988 | for( const XMLNode* node = _next; node; node = node->_next ) {
|
Dmitry-Me | ecb9b07 | 2016-10-12 16:44:59 +0300 | [diff] [blame] | 989 | const XMLElement* element = node->ToElementWithName( name );
|
| 990 | if ( element ) {
|
Dmitry-Me | b6b4e82 | 2014-08-27 17:17:47 +0400 | [diff] [blame] | 991 | return element;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 992 | }
|
| 993 | }
|
| 994 | return 0;
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 995 | }
|
| 996 |
|
| 997 |
|
Dmitry-Me | 886ad97 | 2015-07-22 11:00:51 +0300 | [diff] [blame] | 998 | const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 999 | {
|
Dmitry-Me | 2667aab | 2015-04-03 10:56:59 +0300 | [diff] [blame] | 1000 | for( const XMLNode* node = _prev; node; node = node->_prev ) {
|
Dmitry-Me | ecb9b07 | 2016-10-12 16:44:59 +0300 | [diff] [blame] | 1001 | const XMLElement* element = node->ToElementWithName( name );
|
| 1002 | if ( element ) {
|
Dmitry-Me | b6b4e82 | 2014-08-27 17:17:47 +0400 | [diff] [blame] | 1003 | return element;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1004 | }
|
| 1005 | }
|
| 1006 | return 0;
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1007 | }
|
| 1008 |
|
| 1009 |
|
Dmitry-Me | 10b8ecc | 2017-04-12 17:57:44 +0300 | [diff] [blame] | 1010 | char* XMLNode::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 1011 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1012 | // This is a recursive method, but thinking about it "at the current level"
|
| 1013 | // it is a pretty simple flat list:
|
| 1014 | // <foo/>
|
| 1015 | // <!-- comment -->
|
| 1016 | //
|
| 1017 | // With a special case:
|
| 1018 | // <foo>
|
| 1019 | // </foo>
|
| 1020 | // <!-- comment -->
|
| 1021 | //
|
| 1022 | // Where the closing element (/foo) *must* be the next thing after the opening
|
| 1023 | // element, and the names must match. BUT the tricky bit is that the closing
|
| 1024 | // element will be read by the child.
|
| 1025 | //
|
| 1026 | // 'endTag' is the end tag for this node, it is returned by a call to a child.
|
| 1027 | // 'parentEnd' is the end tag for the parent, which is filled in and returned.
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 1028 |
|
Lee Thomason | d946dda | 2018-04-05 09:11:08 -0700 | [diff] [blame] | 1029 | XMLDocument::DepthTracker tracker(_document);
|
| 1030 | if (_document->Error())
|
| 1031 | return 0;
|
| 1032 |
|
| 1033 | while( p && *p ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1034 | XMLNode* node = 0;
|
Lee Thomason | d627776 | 2012-02-22 16:00:12 -0800 | [diff] [blame] | 1035 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1036 | p = _document->Identify( p, &node );
|
Dmitry-Me | 4336431 | 2016-11-07 18:48:50 +0300 | [diff] [blame] | 1037 | TIXMLASSERT( p );
|
Dmitry-Me | 9fcb876 | 2015-03-05 17:53:34 +0300 | [diff] [blame] | 1038 | if ( node == 0 ) {
|
| 1039 | break;
|
| 1040 | }
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 1041 |
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 1042 | const int initialLineNum = node->_parseLineNum;
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 1043 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1044 | StrPair endTag;
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1045 | p = node->ParseDeep( p, &endTag, curLineNumPtr );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1046 | if ( !p ) {
|
Dmitry-Me | e3225b1 | 2014-09-03 11:03:11 +0400 | [diff] [blame] | 1047 | DeleteNode( node );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1048 | if ( !_document->Error() ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 1049 | _document->SetError( XML_ERROR_PARSING, initialLineNum, 0);
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1050 | }
|
| 1051 | break;
|
| 1052 | }
|
Lee Thomason (grinliz) | 46a14cf | 2012-02-23 22:27:28 -0800 | [diff] [blame] | 1053 |
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 1054 | const XMLDeclaration* const decl = node->ToDeclaration();
|
Sarat Addepalli | a0f499d | 2015-05-18 09:25:17 +0530 | [diff] [blame] | 1055 | if ( decl ) {
|
Dmitry-Me | 446c3bc | 2016-11-11 10:34:56 +0300 | [diff] [blame] | 1056 | // Declarations are only allowed at document level
|
Lee Thomason | db13a82 | 2018-07-28 14:56:20 -0700 | [diff] [blame] | 1057 | //
|
| 1058 | // Multiple declarations are allowed but all declarations
|
| 1059 | // must occur before anything else.
|
| 1060 | //
|
| 1061 | // Optimized due to a security test case. If the first node is
|
| 1062 | // a declaration, and the last node is a declaration, then only
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 1063 | // declarations have so far been added.
|
Lee Thomason | db13a82 | 2018-07-28 14:56:20 -0700 | [diff] [blame] | 1064 | bool wellLocated = false;
|
| 1065 |
|
| 1066 | if (ToDocument()) {
|
| 1067 | if (FirstChild()) {
|
| 1068 | wellLocated =
|
| 1069 | FirstChild() &&
|
| 1070 | FirstChild()->ToDeclaration() &&
|
| 1071 | LastChild() &&
|
| 1072 | LastChild()->ToDeclaration();
|
| 1073 | }
|
| 1074 | else {
|
| 1075 | wellLocated = true;
|
Sarat Addepalli | 2f0d173 | 2015-05-19 09:02:16 +0530 | [diff] [blame] | 1076 | }
|
Dmitry-Me | 446c3bc | 2016-11-11 10:34:56 +0300 | [diff] [blame] | 1077 | }
|
| 1078 | if ( !wellLocated ) {
|
Lee Thomason | f49b965 | 2017-10-11 10:57:49 -0700 | [diff] [blame] | 1079 | _document->SetError( XML_ERROR_PARSING_DECLARATION, initialLineNum, "XMLDeclaration value=%s", decl->Value());
|
Dmitry-Me | 446c3bc | 2016-11-11 10:34:56 +0300 | [diff] [blame] | 1080 | DeleteNode( node );
|
| 1081 | break;
|
| 1082 | }
|
Sarat Addepalli | a0f499d | 2015-05-18 09:25:17 +0530 | [diff] [blame] | 1083 | }
|
Sarat Addepalli | 2f0d173 | 2015-05-19 09:02:16 +0530 | [diff] [blame] | 1084 |
|
Dmitry-Me | b6b4e82 | 2014-08-27 17:17:47 +0400 | [diff] [blame] | 1085 | XMLElement* ele = node->ToElement();
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1086 | if ( ele ) {
|
JayXon | e4bf6e3 | 2014-12-26 01:00:24 -0500 | [diff] [blame] | 1087 | // We read the end tag. Return it to the parent.
|
| 1088 | if ( ele->ClosingType() == XMLElement::CLOSING ) {
|
Dmitry-Me | 10b8ecc | 2017-04-12 17:57:44 +0300 | [diff] [blame] | 1089 | if ( parentEndTag ) {
|
| 1090 | ele->_value.TransferTo( parentEndTag );
|
JayXon | e4bf6e3 | 2014-12-26 01:00:24 -0500 | [diff] [blame] | 1091 | }
|
| 1092 | node->_memPool->SetTracked(); // created and then immediately deleted.
|
| 1093 | DeleteNode( node );
|
| 1094 | return p;
|
| 1095 | }
|
| 1096 |
|
| 1097 | // Handle an end tag returned to this level.
|
| 1098 | // And handle a bunch of annoying errors.
|
Dmitry-Me | 9fb2b0f | 2014-09-23 17:27:39 +0400 | [diff] [blame] | 1099 | bool mismatch = false;
|
Dmitry-Me | 3ae4f3e | 2015-01-09 15:44:16 +0300 | [diff] [blame] | 1100 | if ( endTag.Empty() ) {
|
| 1101 | if ( ele->ClosingType() == XMLElement::OPEN ) {
|
| 1102 | mismatch = true;
|
| 1103 | }
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1104 | }
|
Dmitry-Me | 3ae4f3e | 2015-01-09 15:44:16 +0300 | [diff] [blame] | 1105 | else {
|
| 1106 | if ( ele->ClosingType() != XMLElement::OPEN ) {
|
| 1107 | mismatch = true;
|
| 1108 | }
|
Dmitry-Me | 886ad97 | 2015-07-22 11:00:51 +0300 | [diff] [blame] | 1109 | else if ( !XMLUtil::StringEqual( endTag.GetStr(), ele->Name() ) ) {
|
Dmitry-Me | 9fb2b0f | 2014-09-23 17:27:39 +0400 | [diff] [blame] | 1110 | mismatch = true;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1111 | }
|
| 1112 | }
|
Dmitry-Me | 9fb2b0f | 2014-09-23 17:27:39 +0400 | [diff] [blame] | 1113 | if ( mismatch ) {
|
Lee Thomason | f49b965 | 2017-10-11 10:57:49 -0700 | [diff] [blame] | 1114 | _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, initialLineNum, "XMLElement name=%s", ele->Name());
|
JayXon | dbfdd8f | 2014-12-12 20:07:14 -0500 | [diff] [blame] | 1115 | DeleteNode( node );
|
| 1116 | break;
|
Dmitry-Me | 9fb2b0f | 2014-09-23 17:27:39 +0400 | [diff] [blame] | 1117 | }
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1118 | }
|
JayXon | dbfdd8f | 2014-12-12 20:07:14 -0500 | [diff] [blame] | 1119 | InsertEndChild( node );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1120 | }
|
| 1121 | return 0;
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 1122 | }
|
| 1123 |
|
Lee Thomason | 816d3fa | 2017-06-05 14:35:55 -0700 | [diff] [blame] | 1124 | /*static*/ void XMLNode::DeleteNode( XMLNode* node )
|
Dmitry-Me | e3225b1 | 2014-09-03 11:03:11 +0400 | [diff] [blame] | 1125 | {
|
| 1126 | if ( node == 0 ) {
|
| 1127 | return;
|
| 1128 | }
|
Lee Thomason | 816d3fa | 2017-06-05 14:35:55 -0700 | [diff] [blame] | 1129 | TIXMLASSERT(node->_document);
|
| 1130 | if (!node->ToDocument()) {
|
| 1131 | node->_document->MarkInUse(node);
|
| 1132 | }
|
| 1133 |
|
Dmitry-Me | e3225b1 | 2014-09-03 11:03:11 +0400 | [diff] [blame] | 1134 | MemPool* pool = node->_memPool;
|
| 1135 | node->~XMLNode();
|
| 1136 | pool->Free( node );
|
| 1137 | }
|
| 1138 |
|
Lee Thomason | 3cebdc4 | 2015-01-05 17:16:28 -0800 | [diff] [blame] | 1139 | void XMLNode::InsertChildPreamble( XMLNode* insertThis ) const
|
Dmitry-Me | 74e3940 | 2015-01-01 16:26:17 +0300 | [diff] [blame] | 1140 | {
|
| 1141 | TIXMLASSERT( insertThis );
|
| 1142 | TIXMLASSERT( insertThis->_document == _document );
|
| 1143 |
|
Lee Thomason | 816d3fa | 2017-06-05 14:35:55 -0700 | [diff] [blame] | 1144 | if (insertThis->_parent) {
|
Dmitry-Me | 74e3940 | 2015-01-01 16:26:17 +0300 | [diff] [blame] | 1145 | insertThis->_parent->Unlink( insertThis );
|
Lee Thomason | 816d3fa | 2017-06-05 14:35:55 -0700 | [diff] [blame] | 1146 | }
|
| 1147 | else {
|
| 1148 | insertThis->_document->MarkInUse(insertThis);
|
Dmitry-Me | 74e3940 | 2015-01-01 16:26:17 +0300 | [diff] [blame] | 1149 | insertThis->_memPool->SetTracked();
|
Lee Thomason | 816d3fa | 2017-06-05 14:35:55 -0700 | [diff] [blame] | 1150 | }
|
Dmitry-Me | 74e3940 | 2015-01-01 16:26:17 +0300 | [diff] [blame] | 1151 | }
|
| 1152 |
|
Dmitry-Me | ecb9b07 | 2016-10-12 16:44:59 +0300 | [diff] [blame] | 1153 | const XMLElement* XMLNode::ToElementWithName( const char* name ) const
|
| 1154 | {
|
| 1155 | const XMLElement* element = this->ToElement();
|
| 1156 | if ( element == 0 ) {
|
| 1157 | return 0;
|
| 1158 | }
|
| 1159 | if ( name == 0 ) {
|
| 1160 | return element;
|
| 1161 | }
|
| 1162 | if ( XMLUtil::StringEqual( element->Name(), name ) ) {
|
| 1163 | return element;
|
| 1164 | }
|
| 1165 | return 0;
|
| 1166 | }
|
| 1167 |
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 1168 | // --------- XMLText ---------- //
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1169 | char* XMLText::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 1170 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1171 | if ( this->CData() ) {
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1172 | p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1173 | if ( !p ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 1174 | _document->SetError( XML_ERROR_PARSING_CDATA, _parseLineNum, 0 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1175 | }
|
| 1176 | return p;
|
| 1177 | }
|
| 1178 | else {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1179 | int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;
|
| 1180 | if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {
|
Dmitry-Me | 5420e54 | 2015-05-20 10:51:26 +0300 | [diff] [blame] | 1181 | flags |= StrPair::NEEDS_WHITESPACE_COLLAPSING;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1182 | }
|
Lee Thomason (grinliz) | bc1bfb7 | 2012-08-20 22:00:38 -0700 | [diff] [blame] | 1183 |
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1184 | p = _value.ParseText( p, "<", flags, curLineNumPtr );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1185 | if ( p && *p ) {
|
| 1186 | return p-1;
|
Dmitry-Me | 257e11b | 2015-01-09 15:50:47 +0300 | [diff] [blame] | 1187 | }
|
| 1188 | if ( !p ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 1189 | _document->SetError( XML_ERROR_PARSING_TEXT, _parseLineNum, 0 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1190 | }
|
| 1191 | }
|
| 1192 | return 0;
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 1193 | }
|
| 1194 |
|
| 1195 |
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1196 | XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
|
| 1197 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1198 | if ( !doc ) {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1199 | doc = _document;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1200 | }
|
| 1201 | XMLText* text = doc->NewText( Value() ); // fixme: this will always allocate memory. Intern?
|
| 1202 | text->SetCData( this->CData() );
|
| 1203 | return text;
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1204 | }
|
| 1205 |
|
| 1206 |
|
| 1207 | bool XMLText::ShallowEqual( const XMLNode* compare ) const
|
| 1208 | {
|
Dmitry-Me | ba68a3a | 2017-03-21 11:39:48 +0300 | [diff] [blame] | 1209 | TIXMLASSERT( compare );
|
Dmitry-Me | 6d202ff | 2014-09-26 14:21:00 +0400 | [diff] [blame] | 1210 | const XMLText* text = compare->ToText();
|
| 1211 | return ( text && XMLUtil::StringEqual( text->Value(), Value() ) );
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1212 | }
|
| 1213 |
|
| 1214 |
|
Lee Thomason | 56bdd02 | 2012-02-09 18:16:58 -0800 | [diff] [blame] | 1215 | bool XMLText::Accept( XMLVisitor* visitor ) const
|
| 1216 | {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 1217 | TIXMLASSERT( visitor );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1218 | return visitor->Visit( *this );
|
Lee Thomason | 56bdd02 | 2012-02-09 18:16:58 -0800 | [diff] [blame] | 1219 | }
|
| 1220 |
|
| 1221 |
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 1222 | // --------- XMLComment ---------- //
|
| 1223 |
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 1224 | XMLComment::XMLComment( XMLDocument* doc ) : XMLNode( doc )
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 1225 | {
|
| 1226 | }
|
| 1227 |
|
| 1228 |
|
Lee Thomason | ce0763e | 2012-01-11 15:43:54 -0800 | [diff] [blame] | 1229 | XMLComment::~XMLComment()
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 1230 | {
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 1231 | }
|
| 1232 |
|
| 1233 |
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1234 | char* XMLComment::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 1235 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1236 | // Comment parses as text.
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1237 | p = _value.ParseText( p, "-->", StrPair::COMMENT, curLineNumPtr );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1238 | if ( p == 0 ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 1239 | _document->SetError( XML_ERROR_PARSING_COMMENT, _parseLineNum, 0 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1240 | }
|
| 1241 | return p;
|
U-Lama\Lee | 4cee611 | 2011-12-31 14:58:18 -0800 | [diff] [blame] | 1242 | }
|
| 1243 |
|
| 1244 |
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1245 | XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const
|
| 1246 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1247 | if ( !doc ) {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1248 | doc = _document;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1249 | }
|
| 1250 | XMLComment* comment = doc->NewComment( Value() ); // fixme: this will always allocate memory. Intern?
|
| 1251 | return comment;
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1252 | }
|
| 1253 |
|
| 1254 |
|
| 1255 | bool XMLComment::ShallowEqual( const XMLNode* compare ) const
|
| 1256 | {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 1257 | TIXMLASSERT( compare );
|
Dmitry-Me | b6b4e82 | 2014-08-27 17:17:47 +0400 | [diff] [blame] | 1258 | const XMLComment* comment = compare->ToComment();
|
| 1259 | return ( comment && XMLUtil::StringEqual( comment->Value(), Value() ));
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1260 | }
|
| 1261 |
|
| 1262 |
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 1263 | bool XMLComment::Accept( XMLVisitor* visitor ) const
|
| 1264 | {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 1265 | TIXMLASSERT( visitor );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1266 | return visitor->Visit( *this );
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 1267 | }
|
Lee Thomason | 56bdd02 | 2012-02-09 18:16:58 -0800 | [diff] [blame] | 1268 |
|
| 1269 |
|
Lee Thomason | 50f97b2 | 2012-02-11 16:33:40 -0800 | [diff] [blame] | 1270 | // --------- XMLDeclaration ---------- //
|
| 1271 |
|
| 1272 | XMLDeclaration::XMLDeclaration( XMLDocument* doc ) : XMLNode( doc )
|
| 1273 | {
|
| 1274 | }
|
| 1275 |
|
| 1276 |
|
| 1277 | XMLDeclaration::~XMLDeclaration()
|
| 1278 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1279 | //printf( "~XMLDeclaration\n" );
|
Lee Thomason | 50f97b2 | 2012-02-11 16:33:40 -0800 | [diff] [blame] | 1280 | }
|
| 1281 |
|
| 1282 |
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1283 | char* XMLDeclaration::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
|
Lee Thomason | 50f97b2 | 2012-02-11 16:33:40 -0800 | [diff] [blame] | 1284 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1285 | // Declaration parses as text.
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1286 | p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1287 | if ( p == 0 ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 1288 | _document->SetError( XML_ERROR_PARSING_DECLARATION, _parseLineNum, 0 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1289 | }
|
| 1290 | return p;
|
Lee Thomason | 50f97b2 | 2012-02-11 16:33:40 -0800 | [diff] [blame] | 1291 | }
|
| 1292 |
|
| 1293 |
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1294 | XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const
|
| 1295 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1296 | if ( !doc ) {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1297 | doc = _document;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1298 | }
|
| 1299 | XMLDeclaration* dec = doc->NewDeclaration( Value() ); // fixme: this will always allocate memory. Intern?
|
| 1300 | return dec;
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1301 | }
|
| 1302 |
|
| 1303 |
|
| 1304 | bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const
|
| 1305 | {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 1306 | TIXMLASSERT( compare );
|
Dmitry-Me | b6b4e82 | 2014-08-27 17:17:47 +0400 | [diff] [blame] | 1307 | const XMLDeclaration* declaration = compare->ToDeclaration();
|
| 1308 | return ( declaration && XMLUtil::StringEqual( declaration->Value(), Value() ));
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1309 | }
|
| 1310 |
|
| 1311 |
|
| 1312 |
|
Lee Thomason | 50f97b2 | 2012-02-11 16:33:40 -0800 | [diff] [blame] | 1313 | bool XMLDeclaration::Accept( XMLVisitor* visitor ) const
|
| 1314 | {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 1315 | TIXMLASSERT( visitor );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1316 | return visitor->Visit( *this );
|
Lee Thomason | 50f97b2 | 2012-02-11 16:33:40 -0800 | [diff] [blame] | 1317 | }
|
| 1318 |
|
| 1319 | // --------- XMLUnknown ---------- //
|
| 1320 |
|
| 1321 | XMLUnknown::XMLUnknown( XMLDocument* doc ) : XMLNode( doc )
|
| 1322 | {
|
| 1323 | }
|
| 1324 |
|
| 1325 |
|
| 1326 | XMLUnknown::~XMLUnknown()
|
| 1327 | {
|
| 1328 | }
|
| 1329 |
|
| 1330 |
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1331 | char* XMLUnknown::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
|
Lee Thomason | 50f97b2 | 2012-02-11 16:33:40 -0800 | [diff] [blame] | 1332 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1333 | // Unknown parses as text.
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1334 | p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1335 | if ( !p ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 1336 | _document->SetError( XML_ERROR_PARSING_UNKNOWN, _parseLineNum, 0 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1337 | }
|
| 1338 | return p;
|
Lee Thomason | 50f97b2 | 2012-02-11 16:33:40 -0800 | [diff] [blame] | 1339 | }
|
| 1340 |
|
| 1341 |
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1342 | XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const
|
| 1343 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1344 | if ( !doc ) {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1345 | doc = _document;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1346 | }
|
| 1347 | XMLUnknown* text = doc->NewUnknown( Value() ); // fixme: this will always allocate memory. Intern?
|
| 1348 | return text;
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1349 | }
|
| 1350 |
|
| 1351 |
|
| 1352 | bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const
|
| 1353 | {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 1354 | TIXMLASSERT( compare );
|
Dmitry-Me | b6b4e82 | 2014-08-27 17:17:47 +0400 | [diff] [blame] | 1355 | const XMLUnknown* unknown = compare->ToUnknown();
|
| 1356 | return ( unknown && XMLUtil::StringEqual( unknown->Value(), Value() ));
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 1357 | }
|
| 1358 |
|
| 1359 |
|
Lee Thomason | 50f97b2 | 2012-02-11 16:33:40 -0800 | [diff] [blame] | 1360 | bool XMLUnknown::Accept( XMLVisitor* visitor ) const
|
| 1361 | {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 1362 | TIXMLASSERT( visitor );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1363 | return visitor->Visit( *this );
|
Lee Thomason | 50f97b2 | 2012-02-11 16:33:40 -0800 | [diff] [blame] | 1364 | }
|
| 1365 |
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 1366 | // --------- XMLAttribute ---------- //
|
Michael Daumling | 2162688 | 2013-10-22 17:03:37 +0200 | [diff] [blame] | 1367 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1368 | const char* XMLAttribute::Name() const
|
Michael Daumling | 2162688 | 2013-10-22 17:03:37 +0200 | [diff] [blame] | 1369 | {
|
| 1370 | return _name.GetStr();
|
| 1371 | }
|
| 1372 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1373 | const char* XMLAttribute::Value() const
|
Michael Daumling | 2162688 | 2013-10-22 17:03:37 +0200 | [diff] [blame] | 1374 | {
|
| 1375 | return _value.GetStr();
|
| 1376 | }
|
| 1377 |
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1378 | char* XMLAttribute::ParseDeep( char* p, bool processEntities, int* curLineNumPtr )
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 1379 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1380 | // Parse using the name rules: bug fix, was using ParseText before
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1381 | p = _name.ParseName( p );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1382 | if ( !p || !*p ) {
|
| 1383 | return 0;
|
| 1384 | }
|
Lee Thomason | 22aead1 | 2012-01-23 13:29:35 -0800 | [diff] [blame] | 1385 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1386 | // Skip white space before =
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1387 | p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
|
Dmitry-Me | bb836dc | 2014-12-24 11:54:05 +0300 | [diff] [blame] | 1388 | if ( *p != '=' ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1389 | return 0;
|
| 1390 | }
|
Lee Thomason | 78a773d | 2012-07-02 10:10:19 -0700 | [diff] [blame] | 1391 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1392 | ++p; // move up to opening quote
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1393 | p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1394 | if ( *p != '\"' && *p != '\'' ) {
|
| 1395 | return 0;
|
| 1396 | }
|
Lee Thomason | 78a773d | 2012-07-02 10:10:19 -0700 | [diff] [blame] | 1397 |
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 1398 | const char endTag[2] = { *p, 0 };
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1399 | ++p; // move past opening quote
|
Lee Thomason | 78a773d | 2012-07-02 10:10:19 -0700 | [diff] [blame] | 1400 |
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1401 | p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES, curLineNumPtr );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1402 | return p;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 1403 | }
|
| 1404 |
|
| 1405 |
|
U-Stream\Lee | 09a11c5 | 2012-02-17 08:31:16 -0800 | [diff] [blame] | 1406 | void XMLAttribute::SetName( const char* n )
|
| 1407 | {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1408 | _name.SetStr( n );
|
U-Stream\Lee | 09a11c5 | 2012-02-17 08:31:16 -0800 | [diff] [blame] | 1409 | }
|
| 1410 |
|
| 1411 |
|
Lee Thomason | 2fa8172 | 2012-11-09 12:37:46 -0800 | [diff] [blame] | 1412 | XMLError XMLAttribute::QueryIntValue( int* value ) const
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 1413 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1414 | if ( XMLUtil::ToInt( Value(), value )) {
|
Lee Thomason | 8553625 | 2016-06-04 19:10:53 -0700 | [diff] [blame] | 1415 | return XML_SUCCESS;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1416 | }
|
| 1417 | return XML_WRONG_ATTRIBUTE_TYPE;
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 1418 | }
|
| 1419 |
|
| 1420 |
|
Lee Thomason | 2fa8172 | 2012-11-09 12:37:46 -0800 | [diff] [blame] | 1421 | XMLError XMLAttribute::QueryUnsignedValue( unsigned int* value ) const
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 1422 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1423 | if ( XMLUtil::ToUnsigned( Value(), value )) {
|
Lee Thomason | 8553625 | 2016-06-04 19:10:53 -0700 | [diff] [blame] | 1424 | return XML_SUCCESS;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1425 | }
|
| 1426 | return XML_WRONG_ATTRIBUTE_TYPE;
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 1427 | }
|
| 1428 |
|
| 1429 |
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 1430 | XMLError XMLAttribute::QueryInt64Value(int64_t* value) const
|
| 1431 | {
|
| 1432 | if (XMLUtil::ToInt64(Value(), value)) {
|
| 1433 | return XML_SUCCESS;
|
| 1434 | }
|
| 1435 | return XML_WRONG_ATTRIBUTE_TYPE;
|
| 1436 | }
|
| 1437 |
|
| 1438 |
|
cugone | 75a5acc | 2019-04-11 22:03:43 -0500 | [diff] [blame] | 1439 | XMLError XMLAttribute::QueryUnsigned64Value(uint64_t* value) const
|
| 1440 | {
|
| 1441 | if(XMLUtil::ToUnsigned64(Value(), value)) {
|
| 1442 | return XML_SUCCESS;
|
| 1443 | }
|
| 1444 | return XML_WRONG_ATTRIBUTE_TYPE;
|
| 1445 | }
|
| 1446 |
|
| 1447 |
|
Lee Thomason | 2fa8172 | 2012-11-09 12:37:46 -0800 | [diff] [blame] | 1448 | XMLError XMLAttribute::QueryBoolValue( bool* value ) const
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 1449 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1450 | if ( XMLUtil::ToBool( Value(), value )) {
|
Lee Thomason | 8553625 | 2016-06-04 19:10:53 -0700 | [diff] [blame] | 1451 | return XML_SUCCESS;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1452 | }
|
| 1453 | return XML_WRONG_ATTRIBUTE_TYPE;
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 1454 | }
|
| 1455 |
|
| 1456 |
|
Lee Thomason | 2fa8172 | 2012-11-09 12:37:46 -0800 | [diff] [blame] | 1457 | XMLError XMLAttribute::QueryFloatValue( float* value ) const
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 1458 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1459 | if ( XMLUtil::ToFloat( Value(), value )) {
|
Lee Thomason | 8553625 | 2016-06-04 19:10:53 -0700 | [diff] [blame] | 1460 | return XML_SUCCESS;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1461 | }
|
| 1462 | return XML_WRONG_ATTRIBUTE_TYPE;
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1463 | }
|
| 1464 |
|
| 1465 |
|
Lee Thomason | 2fa8172 | 2012-11-09 12:37:46 -0800 | [diff] [blame] | 1466 | XMLError XMLAttribute::QueryDoubleValue( double* value ) const
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1467 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1468 | if ( XMLUtil::ToDouble( Value(), value )) {
|
Lee Thomason | 8553625 | 2016-06-04 19:10:53 -0700 | [diff] [blame] | 1469 | return XML_SUCCESS;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1470 | }
|
| 1471 | return XML_WRONG_ATTRIBUTE_TYPE;
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 1472 | }
|
| 1473 |
|
| 1474 |
|
| 1475 | void XMLAttribute::SetAttribute( const char* v )
|
| 1476 | {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1477 | _value.SetStr( v );
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 1478 | }
|
| 1479 |
|
| 1480 |
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 1481 | void XMLAttribute::SetAttribute( int v )
|
| 1482 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1483 | char buf[BUF_SIZE];
|
| 1484 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1485 | _value.SetStr( buf );
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 1486 | }
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 1487 |
|
| 1488 |
|
| 1489 | void XMLAttribute::SetAttribute( unsigned v )
|
| 1490 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1491 | char buf[BUF_SIZE];
|
| 1492 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1493 | _value.SetStr( buf );
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 1494 | }
|
| 1495 |
|
| 1496 |
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 1497 | void XMLAttribute::SetAttribute(int64_t v)
|
| 1498 | {
|
| 1499 | char buf[BUF_SIZE];
|
| 1500 | XMLUtil::ToStr(v, buf, BUF_SIZE);
|
| 1501 | _value.SetStr(buf);
|
| 1502 | }
|
| 1503 |
|
Lee Thomason | effdf95 | 2019-08-10 17:49:42 -0700 | [diff] [blame] | 1504 | void XMLAttribute::SetAttribute(uint64_t v)
|
| 1505 | {
|
| 1506 | char buf[BUF_SIZE];
|
| 1507 | XMLUtil::ToStr(v, buf, BUF_SIZE);
|
| 1508 | _value.SetStr(buf);
|
| 1509 | }
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 1510 |
|
| 1511 |
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 1512 | void XMLAttribute::SetAttribute( bool v )
|
| 1513 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1514 | char buf[BUF_SIZE];
|
| 1515 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1516 | _value.SetStr( buf );
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 1517 | }
|
| 1518 |
|
| 1519 | void XMLAttribute::SetAttribute( double v )
|
| 1520 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1521 | char buf[BUF_SIZE];
|
| 1522 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1523 | _value.SetStr( buf );
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 1524 | }
|
| 1525 |
|
| 1526 | void XMLAttribute::SetAttribute( float v )
|
| 1527 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1528 | char buf[BUF_SIZE];
|
| 1529 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1530 | _value.SetStr( buf );
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 1531 | }
|
| 1532 |
|
Lee Thomason | dadcdfa | 2012-01-18 17:55:48 -0800 | [diff] [blame] | 1533 |
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 1534 | // --------- XMLElement ---------- //
|
| 1535 | XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),
|
Dmitry-Me | e503563 | 2017-04-05 18:02:40 +0300 | [diff] [blame] | 1536 | _closingType( OPEN ),
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1537 | _rootAttribute( 0 )
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 1538 | {
|
| 1539 | }
|
| 1540 |
|
| 1541 |
|
| 1542 | XMLElement::~XMLElement()
|
| 1543 | {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1544 | while( _rootAttribute ) {
|
| 1545 | XMLAttribute* next = _rootAttribute->_next;
|
Dmitry-Me | e3225b1 | 2014-09-03 11:03:11 +0400 | [diff] [blame] | 1546 | DeleteAttribute( _rootAttribute );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1547 | _rootAttribute = next;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1548 | }
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 1549 | }
|
| 1550 |
|
| 1551 |
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 1552 | const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
|
| 1553 | {
|
Dmitry-Me | 3659fe1 | 2014-09-04 11:33:49 +0400 | [diff] [blame] | 1554 | for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1555 | if ( XMLUtil::StringEqual( a->Name(), name ) ) {
|
| 1556 | return a;
|
| 1557 | }
|
| 1558 | }
|
| 1559 | return 0;
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 1560 | }
|
| 1561 |
|
| 1562 |
|
Lee Thomason | 8ba7f7d | 2012-03-24 13:04:04 -0700 | [diff] [blame] | 1563 | const char* XMLElement::Attribute( const char* name, const char* value ) const
|
Lee Thomason (grinliz) | 2f1f624 | 2012-09-16 11:32:34 -0700 | [diff] [blame] | 1564 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1565 | const XMLAttribute* a = FindAttribute( name );
|
| 1566 | if ( !a ) {
|
| 1567 | return 0;
|
| 1568 | }
|
| 1569 | if ( !value || XMLUtil::StringEqual( a->Value(), value )) {
|
| 1570 | return a->Value();
|
| 1571 | }
|
| 1572 | return 0;
|
Lee Thomason | 8ba7f7d | 2012-03-24 13:04:04 -0700 | [diff] [blame] | 1573 | }
|
| 1574 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1575 | int XMLElement::IntAttribute(const char* name, int defaultValue) const
|
Josh Wittner | cf3dd09 | 2016-10-11 18:57:17 -0700 | [diff] [blame] | 1576 | {
|
| 1577 | int i = defaultValue;
|
| 1578 | QueryIntAttribute(name, &i);
|
| 1579 | return i;
|
| 1580 | }
|
| 1581 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1582 | unsigned XMLElement::UnsignedAttribute(const char* name, unsigned defaultValue) const
|
Josh Wittner | cf3dd09 | 2016-10-11 18:57:17 -0700 | [diff] [blame] | 1583 | {
|
| 1584 | unsigned i = defaultValue;
|
| 1585 | QueryUnsignedAttribute(name, &i);
|
| 1586 | return i;
|
| 1587 | }
|
| 1588 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1589 | int64_t XMLElement::Int64Attribute(const char* name, int64_t defaultValue) const
|
Josh Wittner | cf3dd09 | 2016-10-11 18:57:17 -0700 | [diff] [blame] | 1590 | {
|
| 1591 | int64_t i = defaultValue;
|
| 1592 | QueryInt64Attribute(name, &i);
|
| 1593 | return i;
|
| 1594 | }
|
| 1595 |
|
aaronkirkham07@gmail.com | c341cea | 2019-05-22 00:05:27 +0100 | [diff] [blame] | 1596 | uint64_t XMLElement::Unsigned64Attribute(const char* name, uint64_t defaultValue) const
|
| 1597 | {
|
| 1598 | uint64_t i = defaultValue;
|
| 1599 | QueryUnsigned64Attribute(name, &i);
|
| 1600 | return i;
|
| 1601 | }
|
| 1602 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1603 | bool XMLElement::BoolAttribute(const char* name, bool defaultValue) const
|
Josh Wittner | cf3dd09 | 2016-10-11 18:57:17 -0700 | [diff] [blame] | 1604 | {
|
| 1605 | bool b = defaultValue;
|
| 1606 | QueryBoolAttribute(name, &b);
|
| 1607 | return b;
|
| 1608 | }
|
| 1609 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1610 | double XMLElement::DoubleAttribute(const char* name, double defaultValue) const
|
Josh Wittner | cf3dd09 | 2016-10-11 18:57:17 -0700 | [diff] [blame] | 1611 | {
|
| 1612 | double d = defaultValue;
|
| 1613 | QueryDoubleAttribute(name, &d);
|
| 1614 | return d;
|
| 1615 | }
|
| 1616 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1617 | float XMLElement::FloatAttribute(const char* name, float defaultValue) const
|
Josh Wittner | cf3dd09 | 2016-10-11 18:57:17 -0700 | [diff] [blame] | 1618 | {
|
| 1619 | float f = defaultValue;
|
| 1620 | QueryFloatAttribute(name, &f);
|
| 1621 | return f;
|
| 1622 | }
|
Lee Thomason | 8ba7f7d | 2012-03-24 13:04:04 -0700 | [diff] [blame] | 1623 |
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 1624 | const char* XMLElement::GetText() const
|
| 1625 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1626 | if ( FirstChild() && FirstChild()->ToText() ) {
|
Dmitry-Me | 097339a | 2014-09-29 13:20:29 +0400 | [diff] [blame] | 1627 | return FirstChild()->Value();
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1628 | }
|
| 1629 | return 0;
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 1630 | }
|
| 1631 |
|
| 1632 |
|
Uli Kusterer | 8fe342a | 2014-01-21 01:12:47 +0100 | [diff] [blame] | 1633 | void XMLElement::SetText( const char* inText )
|
| 1634 | {
|
Uli Kusterer | 869bb59 | 2014-01-21 01:36:16 +0100 | [diff] [blame] | 1635 | if ( FirstChild() && FirstChild()->ToText() )
|
Uli Kusterer | 8fe342a | 2014-01-21 01:12:47 +0100 | [diff] [blame] | 1636 | FirstChild()->SetValue( inText );
|
| 1637 | else {
|
| 1638 | XMLText* theText = GetDocument()->NewText( inText );
|
| 1639 | InsertFirstChild( theText );
|
| 1640 | }
|
| 1641 | }
|
| 1642 |
|
Lee Thomason | 5bb2d80 | 2014-01-24 10:42:57 -0800 | [diff] [blame] | 1643 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1644 | void XMLElement::SetText( int v )
|
Lee Thomason | 5bb2d80 | 2014-01-24 10:42:57 -0800 | [diff] [blame] | 1645 | {
|
| 1646 | char buf[BUF_SIZE];
|
| 1647 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
| 1648 | SetText( buf );
|
| 1649 | }
|
| 1650 |
|
| 1651 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1652 | void XMLElement::SetText( unsigned v )
|
Lee Thomason | 5bb2d80 | 2014-01-24 10:42:57 -0800 | [diff] [blame] | 1653 | {
|
| 1654 | char buf[BUF_SIZE];
|
| 1655 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
| 1656 | SetText( buf );
|
| 1657 | }
|
| 1658 |
|
| 1659 |
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 1660 | void XMLElement::SetText(int64_t v)
|
| 1661 | {
|
| 1662 | char buf[BUF_SIZE];
|
| 1663 | XMLUtil::ToStr(v, buf, BUF_SIZE);
|
| 1664 | SetText(buf);
|
| 1665 | }
|
| 1666 |
|
cugone | 47e229e | 2019-04-12 17:27:28 -0500 | [diff] [blame] | 1667 | void XMLElement::SetText(uint64_t v) {
|
| 1668 | char buf[BUF_SIZE];
|
| 1669 | XMLUtil::ToStr(v, buf, BUF_SIZE);
|
| 1670 | SetText(buf);
|
| 1671 | }
|
| 1672 |
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 1673 |
|
| 1674 | void XMLElement::SetText( bool v )
|
Lee Thomason | 5bb2d80 | 2014-01-24 10:42:57 -0800 | [diff] [blame] | 1675 | {
|
| 1676 | char buf[BUF_SIZE];
|
| 1677 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
| 1678 | SetText( buf );
|
| 1679 | }
|
| 1680 |
|
| 1681 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1682 | void XMLElement::SetText( float v )
|
Lee Thomason | 5bb2d80 | 2014-01-24 10:42:57 -0800 | [diff] [blame] | 1683 | {
|
| 1684 | char buf[BUF_SIZE];
|
| 1685 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
| 1686 | SetText( buf );
|
| 1687 | }
|
| 1688 |
|
| 1689 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 1690 | void XMLElement::SetText( double v )
|
Lee Thomason | 5bb2d80 | 2014-01-24 10:42:57 -0800 | [diff] [blame] | 1691 | {
|
| 1692 | char buf[BUF_SIZE];
|
| 1693 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
| 1694 | SetText( buf );
|
| 1695 | }
|
| 1696 |
|
| 1697 |
|
MortenMacFly | 4ee49f1 | 2013-01-14 20:03:14 +0100 | [diff] [blame] | 1698 | XMLError XMLElement::QueryIntText( int* ival ) const
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1699 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1700 | if ( FirstChild() && FirstChild()->ToText() ) {
|
Dmitry-Me | 097339a | 2014-09-29 13:20:29 +0400 | [diff] [blame] | 1701 | const char* t = FirstChild()->Value();
|
MortenMacFly | 4ee49f1 | 2013-01-14 20:03:14 +0100 | [diff] [blame] | 1702 | if ( XMLUtil::ToInt( t, ival ) ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1703 | return XML_SUCCESS;
|
| 1704 | }
|
| 1705 | return XML_CAN_NOT_CONVERT_TEXT;
|
| 1706 | }
|
| 1707 | return XML_NO_TEXT_NODE;
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1708 | }
|
| 1709 |
|
| 1710 |
|
MortenMacFly | 4ee49f1 | 2013-01-14 20:03:14 +0100 | [diff] [blame] | 1711 | XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1712 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1713 | if ( FirstChild() && FirstChild()->ToText() ) {
|
Dmitry-Me | 097339a | 2014-09-29 13:20:29 +0400 | [diff] [blame] | 1714 | const char* t = FirstChild()->Value();
|
MortenMacFly | 4ee49f1 | 2013-01-14 20:03:14 +0100 | [diff] [blame] | 1715 | if ( XMLUtil::ToUnsigned( t, uval ) ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1716 | return XML_SUCCESS;
|
| 1717 | }
|
| 1718 | return XML_CAN_NOT_CONVERT_TEXT;
|
| 1719 | }
|
| 1720 | return XML_NO_TEXT_NODE;
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1721 | }
|
| 1722 |
|
| 1723 |
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 1724 | XMLError XMLElement::QueryInt64Text(int64_t* ival) const
|
| 1725 | {
|
| 1726 | if (FirstChild() && FirstChild()->ToText()) {
|
| 1727 | const char* t = FirstChild()->Value();
|
| 1728 | if (XMLUtil::ToInt64(t, ival)) {
|
| 1729 | return XML_SUCCESS;
|
| 1730 | }
|
| 1731 | return XML_CAN_NOT_CONVERT_TEXT;
|
| 1732 | }
|
| 1733 | return XML_NO_TEXT_NODE;
|
| 1734 | }
|
| 1735 |
|
| 1736 |
|
cugone | 1dbfe31 | 2019-04-12 17:33:49 -0500 | [diff] [blame] | 1737 | XMLError XMLElement::QueryUnsigned64Text(uint64_t* ival) const
|
| 1738 | {
|
cugone | 47e229e | 2019-04-12 17:27:28 -0500 | [diff] [blame] | 1739 | if(FirstChild() && FirstChild()->ToText()) {
|
| 1740 | const char* t = FirstChild()->Value();
|
| 1741 | if(XMLUtil::ToUnsigned64(t, ival)) {
|
| 1742 | return XML_SUCCESS;
|
| 1743 | }
|
| 1744 | return XML_CAN_NOT_CONVERT_TEXT;
|
| 1745 | }
|
| 1746 | return XML_NO_TEXT_NODE;
|
| 1747 | }
|
| 1748 |
|
| 1749 |
|
MortenMacFly | 4ee49f1 | 2013-01-14 20:03:14 +0100 | [diff] [blame] | 1750 | XMLError XMLElement::QueryBoolText( bool* bval ) const
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1751 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1752 | if ( FirstChild() && FirstChild()->ToText() ) {
|
Dmitry-Me | 097339a | 2014-09-29 13:20:29 +0400 | [diff] [blame] | 1753 | const char* t = FirstChild()->Value();
|
MortenMacFly | 4ee49f1 | 2013-01-14 20:03:14 +0100 | [diff] [blame] | 1754 | if ( XMLUtil::ToBool( t, bval ) ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1755 | return XML_SUCCESS;
|
| 1756 | }
|
| 1757 | return XML_CAN_NOT_CONVERT_TEXT;
|
| 1758 | }
|
| 1759 | return XML_NO_TEXT_NODE;
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1760 | }
|
| 1761 |
|
| 1762 |
|
MortenMacFly | 4ee49f1 | 2013-01-14 20:03:14 +0100 | [diff] [blame] | 1763 | XMLError XMLElement::QueryDoubleText( double* dval ) const
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1764 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1765 | if ( FirstChild() && FirstChild()->ToText() ) {
|
Dmitry-Me | 097339a | 2014-09-29 13:20:29 +0400 | [diff] [blame] | 1766 | const char* t = FirstChild()->Value();
|
MortenMacFly | 4ee49f1 | 2013-01-14 20:03:14 +0100 | [diff] [blame] | 1767 | if ( XMLUtil::ToDouble( t, dval ) ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1768 | return XML_SUCCESS;
|
| 1769 | }
|
| 1770 | return XML_CAN_NOT_CONVERT_TEXT;
|
| 1771 | }
|
| 1772 | return XML_NO_TEXT_NODE;
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1773 | }
|
| 1774 |
|
| 1775 |
|
MortenMacFly | 4ee49f1 | 2013-01-14 20:03:14 +0100 | [diff] [blame] | 1776 | XMLError XMLElement::QueryFloatText( float* fval ) const
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1777 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1778 | if ( FirstChild() && FirstChild()->ToText() ) {
|
Dmitry-Me | 097339a | 2014-09-29 13:20:29 +0400 | [diff] [blame] | 1779 | const char* t = FirstChild()->Value();
|
MortenMacFly | 4ee49f1 | 2013-01-14 20:03:14 +0100 | [diff] [blame] | 1780 | if ( XMLUtil::ToFloat( t, fval ) ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1781 | return XML_SUCCESS;
|
| 1782 | }
|
| 1783 | return XML_CAN_NOT_CONVERT_TEXT;
|
| 1784 | }
|
| 1785 | return XML_NO_TEXT_NODE;
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1786 | }
|
| 1787 |
|
Josh Wittner | cf3dd09 | 2016-10-11 18:57:17 -0700 | [diff] [blame] | 1788 | int XMLElement::IntText(int defaultValue) const
|
| 1789 | {
|
| 1790 | int i = defaultValue;
|
| 1791 | QueryIntText(&i);
|
| 1792 | return i;
|
| 1793 | }
|
| 1794 |
|
| 1795 | unsigned XMLElement::UnsignedText(unsigned defaultValue) const
|
| 1796 | {
|
| 1797 | unsigned i = defaultValue;
|
| 1798 | QueryUnsignedText(&i);
|
| 1799 | return i;
|
| 1800 | }
|
| 1801 |
|
| 1802 | int64_t XMLElement::Int64Text(int64_t defaultValue) const
|
| 1803 | {
|
| 1804 | int64_t i = defaultValue;
|
| 1805 | QueryInt64Text(&i);
|
| 1806 | return i;
|
| 1807 | }
|
| 1808 |
|
cugone | 1dbfe31 | 2019-04-12 17:33:49 -0500 | [diff] [blame] | 1809 | uint64_t XMLElement::Unsigned64Text(uint64_t defaultValue) const
|
| 1810 | {
|
| 1811 | uint64_t i = defaultValue;
|
| 1812 | QueryUnsigned64Text(&i);
|
| 1813 | return i;
|
| 1814 | }
|
| 1815 |
|
Josh Wittner | cf3dd09 | 2016-10-11 18:57:17 -0700 | [diff] [blame] | 1816 | bool XMLElement::BoolText(bool defaultValue) const
|
| 1817 | {
|
| 1818 | bool b = defaultValue;
|
| 1819 | QueryBoolText(&b);
|
| 1820 | return b;
|
| 1821 | }
|
| 1822 |
|
| 1823 | double XMLElement::DoubleText(double defaultValue) const
|
| 1824 | {
|
| 1825 | double d = defaultValue;
|
| 1826 | QueryDoubleText(&d);
|
| 1827 | return d;
|
| 1828 | }
|
| 1829 |
|
| 1830 | float XMLElement::FloatText(float defaultValue) const
|
| 1831 | {
|
| 1832 | float f = defaultValue;
|
| 1833 | QueryFloatText(&f);
|
| 1834 | return f;
|
| 1835 | }
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 1836 |
|
| 1837 |
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 1838 | XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
|
| 1839 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1840 | XMLAttribute* last = 0;
|
| 1841 | XMLAttribute* attrib = 0;
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1842 | for( attrib = _rootAttribute;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1843 | attrib;
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1844 | last = attrib, attrib = attrib->_next ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1845 | if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {
|
| 1846 | break;
|
| 1847 | }
|
| 1848 | }
|
| 1849 | if ( !attrib ) {
|
Dmitry-Me | a60caa2 | 2016-11-22 18:28:08 +0300 | [diff] [blame] | 1850 | attrib = CreateAttribute();
|
| 1851 | TIXMLASSERT( attrib );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1852 | if ( last ) {
|
Dmitry-Me | 34a3f8e | 2016-12-19 12:05:21 +0300 | [diff] [blame] | 1853 | TIXMLASSERT( last->_next == 0 );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1854 | last->_next = attrib;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1855 | }
|
| 1856 | else {
|
Dmitry-Me | 34a3f8e | 2016-12-19 12:05:21 +0300 | [diff] [blame] | 1857 | TIXMLASSERT( _rootAttribute == 0 );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1858 | _rootAttribute = attrib;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1859 | }
|
| 1860 | attrib->SetName( name );
|
| 1861 | }
|
| 1862 | return attrib;
|
Lee Thomason | 1a1d4a7 | 2012-02-15 09:09:25 -0800 | [diff] [blame] | 1863 | }
|
| 1864 |
|
| 1865 |
|
U-Stream\Lee | ae25a44 | 2012-02-17 17:48:16 -0800 | [diff] [blame] | 1866 | void XMLElement::DeleteAttribute( const char* name )
|
| 1867 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1868 | XMLAttribute* prev = 0;
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1869 | for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1870 | if ( XMLUtil::StringEqual( name, a->Name() ) ) {
|
| 1871 | if ( prev ) {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1872 | prev->_next = a->_next;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1873 | }
|
| 1874 | else {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1875 | _rootAttribute = a->_next;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1876 | }
|
Dmitry-Me | e3225b1 | 2014-09-03 11:03:11 +0400 | [diff] [blame] | 1877 | DeleteAttribute( a );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1878 | break;
|
| 1879 | }
|
| 1880 | prev = a;
|
| 1881 | }
|
U-Stream\Lee | ae25a44 | 2012-02-17 17:48:16 -0800 | [diff] [blame] | 1882 | }
|
| 1883 |
|
| 1884 |
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1885 | char* XMLElement::ParseAttributes( char* p, int* curLineNumPtr )
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 1886 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1887 | XMLAttribute* prevAttribute = 0;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 1888 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1889 | // Read the attributes.
|
| 1890 | while( p ) {
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1891 | p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
|
Dmitry-Me | bb836dc | 2014-12-24 11:54:05 +0300 | [diff] [blame] | 1892 | if ( !(*p) ) {
|
Lee Thomason | f49b965 | 2017-10-11 10:57:49 -0700 | [diff] [blame] | 1893 | _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, "XMLElement name=%s", Name() );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1894 | return 0;
|
| 1895 | }
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 1896 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1897 | // attribute.
|
Martinsh Shaiters | c6d02f4 | 2013-01-26 21:22:57 +0200 | [diff] [blame] | 1898 | if (XMLUtil::IsNameStartChar( *p ) ) {
|
Dmitry-Me | a60caa2 | 2016-11-22 18:28:08 +0300 | [diff] [blame] | 1899 | XMLAttribute* attrib = CreateAttribute();
|
| 1900 | TIXMLASSERT( attrib );
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 1901 | attrib->_parseLineNum = _document->_parseCurLineNum;
|
Lee Thomason | d198322 | 2012-02-06 08:41:24 -0800 | [diff] [blame] | 1902 |
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 1903 | const int attrLineNum = attrib->_parseLineNum;
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 1904 |
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 1905 | p = attrib->ParseDeep( p, _document->ProcessEntities(), curLineNumPtr );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1906 | if ( !p || Attribute( attrib->Name() ) ) {
|
Dmitry-Me | e3225b1 | 2014-09-03 11:03:11 +0400 | [diff] [blame] | 1907 | DeleteAttribute( attrib );
|
Lee Thomason | f49b965 | 2017-10-11 10:57:49 -0700 | [diff] [blame] | 1908 | _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, attrLineNum, "XMLElement name=%s", Name() );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1909 | return 0;
|
| 1910 | }
|
| 1911 | // There is a minor bug here: if the attribute in the source xml
|
| 1912 | // document is duplicated, it will not be detected and the
|
| 1913 | // attribute will be doubly added. However, tracking the 'prevAttribute'
|
| 1914 | // avoids re-scanning the attribute list. Preferring performance for
|
| 1915 | // now, may reconsider in the future.
|
| 1916 | if ( prevAttribute ) {
|
Dmitry-Me | 34a3f8e | 2016-12-19 12:05:21 +0300 | [diff] [blame] | 1917 | TIXMLASSERT( prevAttribute->_next == 0 );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1918 | prevAttribute->_next = attrib;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1919 | }
|
| 1920 | else {
|
Dmitry-Me | 34a3f8e | 2016-12-19 12:05:21 +0300 | [diff] [blame] | 1921 | TIXMLASSERT( _rootAttribute == 0 );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 1922 | _rootAttribute = attrib;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1923 | }
|
| 1924 | prevAttribute = attrib;
|
| 1925 | }
|
| 1926 | // end of the tag
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1927 | else if ( *p == '>' ) {
|
| 1928 | ++p;
|
| 1929 | break;
|
| 1930 | }
|
Dmitry-Me | ccd267a | 2015-04-10 15:42:54 +0300 | [diff] [blame] | 1931 | // end of the tag
|
| 1932 | else if ( *p == '/' && *(p+1) == '>' ) {
|
| 1933 | _closingType = CLOSED;
|
| 1934 | return p+2; // done; sealed element.
|
| 1935 | }
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1936 | else {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 1937 | _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, 0 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 1938 | return 0;
|
| 1939 | }
|
| 1940 | }
|
| 1941 | return p;
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 1942 | }
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 1943 |
|
Dmitry-Me | e3225b1 | 2014-09-03 11:03:11 +0400 | [diff] [blame] | 1944 | void XMLElement::DeleteAttribute( XMLAttribute* attribute )
|
| 1945 | {
|
| 1946 | if ( attribute == 0 ) {
|
| 1947 | return;
|
| 1948 | }
|
| 1949 | MemPool* pool = attribute->_memPool;
|
| 1950 | attribute->~XMLAttribute();
|
| 1951 | pool->Free( attribute );
|
| 1952 | }
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 1953 |
|
Dmitry-Me | a60caa2 | 2016-11-22 18:28:08 +0300 | [diff] [blame] | 1954 | XMLAttribute* XMLElement::CreateAttribute()
|
| 1955 | {
|
| 1956 | TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );
|
| 1957 | XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
|
Dmitry-Me | 7221b49 | 2017-03-03 15:45:51 +0300 | [diff] [blame] | 1958 | TIXMLASSERT( attrib );
|
Dmitry-Me | a60caa2 | 2016-11-22 18:28:08 +0300 | [diff] [blame] | 1959 | attrib->_memPool = &_document->_attributePool;
|
| 1960 | attrib->_memPool->SetTracked();
|
| 1961 | return attrib;
|
| 1962 | }
|
| 1963 |
|
ngc92 | e620245 | 2019-12-03 16:25:53 +0100 | [diff] [blame] | 1964 |
|
Lee Thomason | e444268 | 2020-03-01 17:10:38 -0800 | [diff] [blame] | 1965 | XMLElement* XMLElement::InsertNewChildElement(const char* name)
|
ngc92 | e620245 | 2019-12-03 16:25:53 +0100 | [diff] [blame] | 1966 | {
|
Lee Thomason | e444268 | 2020-03-01 17:10:38 -0800 | [diff] [blame] | 1967 | XMLElement* node = _document->NewElement(name);
|
| 1968 | return InsertEndChild(node) ? node : 0;
|
ngc92 | e620245 | 2019-12-03 16:25:53 +0100 | [diff] [blame] | 1969 | }
|
| 1970 |
|
Lee Thomason | e444268 | 2020-03-01 17:10:38 -0800 | [diff] [blame] | 1971 | XMLComment* XMLElement::InsertNewComment(const char* comment)
|
ngc92 | e620245 | 2019-12-03 16:25:53 +0100 | [diff] [blame] | 1972 | {
|
Lee Thomason | e444268 | 2020-03-01 17:10:38 -0800 | [diff] [blame] | 1973 | XMLComment* node = _document->NewComment(comment);
|
| 1974 | return InsertEndChild(node) ? node : 0;
|
ngc92 | e620245 | 2019-12-03 16:25:53 +0100 | [diff] [blame] | 1975 | }
|
| 1976 |
|
Lee Thomason | e444268 | 2020-03-01 17:10:38 -0800 | [diff] [blame] | 1977 | XMLText* XMLElement::InsertNewText(const char* text)
|
ngc92 | e620245 | 2019-12-03 16:25:53 +0100 | [diff] [blame] | 1978 | {
|
Lee Thomason | e444268 | 2020-03-01 17:10:38 -0800 | [diff] [blame] | 1979 | XMLText* node = _document->NewText(text);
|
| 1980 | return InsertEndChild(node) ? node : 0;
|
ngc92 | e620245 | 2019-12-03 16:25:53 +0100 | [diff] [blame] | 1981 | }
|
| 1982 |
|
Lee Thomason | e444268 | 2020-03-01 17:10:38 -0800 | [diff] [blame] | 1983 | XMLDeclaration* XMLElement::InsertNewDeclaration(const char* text)
|
ngc92 | e620245 | 2019-12-03 16:25:53 +0100 | [diff] [blame] | 1984 | {
|
Lee Thomason | e444268 | 2020-03-01 17:10:38 -0800 | [diff] [blame] | 1985 | XMLDeclaration* node = _document->NewDeclaration(text);
|
| 1986 | return InsertEndChild(node) ? node : 0;
|
ngc92 | e620245 | 2019-12-03 16:25:53 +0100 | [diff] [blame] | 1987 | }
|
| 1988 |
|
Lee Thomason | e444268 | 2020-03-01 17:10:38 -0800 | [diff] [blame] | 1989 | XMLUnknown* XMLElement::InsertNewUnknown(const char* text)
|
ngc92 | e620245 | 2019-12-03 16:25:53 +0100 | [diff] [blame] | 1990 | {
|
Lee Thomason | e444268 | 2020-03-01 17:10:38 -0800 | [diff] [blame] | 1991 | XMLUnknown* node = _document->NewUnknown(text);
|
| 1992 | return InsertEndChild(node) ? node : 0;
|
ngc92 | e620245 | 2019-12-03 16:25:53 +0100 | [diff] [blame] | 1993 | }
|
| 1994 |
|
| 1995 |
|
| 1996 |
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 1997 | //
|
| 1998 | // <ele></ele>
|
| 1999 | // <ele>foo<b>bar</b></ele>
|
| 2000 | //
|
Dmitry-Me | 10b8ecc | 2017-04-12 17:57:44 +0300 | [diff] [blame] | 2001 | char* XMLElement::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 2002 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2003 | // Read the element name.
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 2004 | p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 2005 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2006 | // The closing element is the </element> form. It is
|
| 2007 | // parsed just like a regular element then deleted from
|
| 2008 | // the DOM.
|
| 2009 | if ( *p == '/' ) {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2010 | _closingType = CLOSING;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2011 | ++p;
|
| 2012 | }
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 2013 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2014 | p = _value.ParseName( p );
|
| 2015 | if ( _value.Empty() ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2016 | return 0;
|
| 2017 | }
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 2018 |
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 2019 | p = ParseAttributes( p, curLineNumPtr );
|
Dmitry-Me | e503563 | 2017-04-05 18:02:40 +0300 | [diff] [blame] | 2020 | if ( !p || !*p || _closingType != OPEN ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2021 | return p;
|
| 2022 | }
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 2023 |
|
Dmitry-Me | 10b8ecc | 2017-04-12 17:57:44 +0300 | [diff] [blame] | 2024 | p = XMLNode::ParseDeep( p, parentEndTag, curLineNumPtr );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2025 | return p;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 2026 | }
|
| 2027 |
|
| 2028 |
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2029 |
|
| 2030 | XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const
|
| 2031 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2032 | if ( !doc ) {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2033 | doc = _document;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2034 | }
|
| 2035 | XMLElement* element = doc->NewElement( Value() ); // fixme: this will always allocate memory. Intern?
|
| 2036 | for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) {
|
| 2037 | element->SetAttribute( a->Name(), a->Value() ); // fixme: this will always allocate memory. Intern?
|
| 2038 | }
|
| 2039 | return element;
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2040 | }
|
| 2041 |
|
| 2042 |
|
| 2043 | bool XMLElement::ShallowEqual( const XMLNode* compare ) const
|
| 2044 | {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 2045 | TIXMLASSERT( compare );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2046 | const XMLElement* other = compare->ToElement();
|
Dmitry-Me | 886ad97 | 2015-07-22 11:00:51 +0300 | [diff] [blame] | 2047 | if ( other && XMLUtil::StringEqual( other->Name(), Name() )) {
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2048 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2049 | const XMLAttribute* a=FirstAttribute();
|
| 2050 | const XMLAttribute* b=other->FirstAttribute();
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2051 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2052 | while ( a && b ) {
|
| 2053 | if ( !XMLUtil::StringEqual( a->Value(), b->Value() ) ) {
|
| 2054 | return false;
|
| 2055 | }
|
| 2056 | a = a->Next();
|
| 2057 | b = b->Next();
|
| 2058 | }
|
| 2059 | if ( a || b ) {
|
| 2060 | // different count
|
| 2061 | return false;
|
| 2062 | }
|
| 2063 | return true;
|
| 2064 | }
|
| 2065 | return false;
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2066 | }
|
| 2067 |
|
| 2068 |
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 2069 | bool XMLElement::Accept( XMLVisitor* visitor ) const
|
| 2070 | {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 2071 | TIXMLASSERT( visitor );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2072 | if ( visitor->VisitEnter( *this, _rootAttribute ) ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2073 | for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
|
| 2074 | if ( !node->Accept( visitor ) ) {
|
| 2075 | break;
|
| 2076 | }
|
| 2077 | }
|
| 2078 | }
|
| 2079 | return visitor->VisitExit( *this );
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 2080 | }
|
Lee Thomason | 56bdd02 | 2012-02-09 18:16:58 -0800 | [diff] [blame] | 2081 |
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2082 |
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 2083 | // --------- XMLDocument ----------- //
|
Lee Thomason | 331596e | 2014-09-11 14:56:43 -0700 | [diff] [blame] | 2084 |
|
| 2085 | // Warning: List must match 'enum XMLError'
|
| 2086 | const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {
|
| 2087 | "XML_SUCCESS",
|
| 2088 | "XML_NO_ATTRIBUTE",
|
| 2089 | "XML_WRONG_ATTRIBUTE_TYPE",
|
| 2090 | "XML_ERROR_FILE_NOT_FOUND",
|
| 2091 | "XML_ERROR_FILE_COULD_NOT_BE_OPENED",
|
| 2092 | "XML_ERROR_FILE_READ_ERROR",
|
Lee Thomason | 331596e | 2014-09-11 14:56:43 -0700 | [diff] [blame] | 2093 | "XML_ERROR_PARSING_ELEMENT",
|
| 2094 | "XML_ERROR_PARSING_ATTRIBUTE",
|
Lee Thomason | 331596e | 2014-09-11 14:56:43 -0700 | [diff] [blame] | 2095 | "XML_ERROR_PARSING_TEXT",
|
| 2096 | "XML_ERROR_PARSING_CDATA",
|
| 2097 | "XML_ERROR_PARSING_COMMENT",
|
| 2098 | "XML_ERROR_PARSING_DECLARATION",
|
| 2099 | "XML_ERROR_PARSING_UNKNOWN",
|
| 2100 | "XML_ERROR_EMPTY_DOCUMENT",
|
| 2101 | "XML_ERROR_MISMATCHED_ELEMENT",
|
| 2102 | "XML_ERROR_PARSING",
|
| 2103 | "XML_CAN_NOT_CONVERT_TEXT",
|
Lee Thomason | d946dda | 2018-04-05 09:11:08 -0700 | [diff] [blame] | 2104 | "XML_NO_TEXT_NODE",
|
| 2105 | "XML_ELEMENT_DEPTH_EXCEEDED"
|
Lee Thomason | 331596e | 2014-09-11 14:56:43 -0700 | [diff] [blame] | 2106 | };
|
| 2107 |
|
| 2108 |
|
Dmitry-Me | ae8a82a | 2017-03-03 15:40:32 +0300 | [diff] [blame] | 2109 | XMLDocument::XMLDocument( bool processEntities, Whitespace whitespaceMode ) :
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2110 | XMLNode( 0 ),
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2111 | _writeBOM( false ),
|
| 2112 | _processEntities( processEntities ),
|
Lee Thomason | 8553625 | 2016-06-04 19:10:53 -0700 | [diff] [blame] | 2113 | _errorID(XML_SUCCESS),
|
Dmitry-Me | ae8a82a | 2017-03-03 15:40:32 +0300 | [diff] [blame] | 2114 | _whitespaceMode( whitespaceMode ),
|
Lee Thomason | 0c0f98b | 2017-10-11 11:03:49 -0700 | [diff] [blame] | 2115 | _errorStr(),
|
Dmitry-Me | f89bd3e | 2017-01-18 18:33:55 +0300 | [diff] [blame] | 2116 | _errorLineNum( 0 ),
|
| 2117 | _charBuffer( 0 ),
|
Thierry Lelegard | 7f0f754 | 2017-09-01 10:14:16 +0200 | [diff] [blame] | 2118 | _parseCurLineNum( 0 ),
|
Lee Thomason | d946dda | 2018-04-05 09:11:08 -0700 | [diff] [blame] | 2119 | _parsingDepth(0),
|
Thierry Lelegard | 7f0f754 | 2017-09-01 10:14:16 +0200 | [diff] [blame] | 2120 | _unlinked(),
|
| 2121 | _elementPool(),
|
| 2122 | _attributePool(),
|
| 2123 | _textPool(),
|
| 2124 | _commentPool()
|
U-Lama\Lee | 560bd47 | 2011-12-28 19:42:49 -0800 | [diff] [blame] | 2125 | {
|
Dmitry-Me | 8dd493b | 2015-07-02 13:59:30 +0300 | [diff] [blame] | 2126 | // avoid VC++ C4355 warning about 'this' in initializer list (C4355 is off by default in VS2012+)
|
| 2127 | _document = this;
|
U-Lama\Lee | 560bd47 | 2011-12-28 19:42:49 -0800 | [diff] [blame] | 2128 | }
|
U-Lama\Lee | e13c3e6 | 2011-12-28 14:36:55 -0800 | [diff] [blame] | 2129 |
|
| 2130 |
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 2131 | XMLDocument::~XMLDocument()
|
| 2132 | {
|
Lee Thomason | f07b952 | 2014-10-30 13:25:12 -0700 | [diff] [blame] | 2133 | Clear();
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 2134 | }
|
| 2135 |
|
| 2136 |
|
orbitcowboy | 73f5409 | 2019-08-14 09:30:30 +0200 | [diff] [blame] | 2137 | void XMLDocument::MarkInUse(const XMLNode* const node)
|
Lee Thomason | 816d3fa | 2017-06-05 14:35:55 -0700 | [diff] [blame] | 2138 | {
|
Dmitry-Me | c2f677b | 2017-06-15 12:44:27 +0300 | [diff] [blame] | 2139 | TIXMLASSERT(node);
|
Lee Thomason | 816d3fa | 2017-06-05 14:35:55 -0700 | [diff] [blame] | 2140 | TIXMLASSERT(node->_parent == 0);
|
| 2141 |
|
| 2142 | for (int i = 0; i < _unlinked.Size(); ++i) {
|
| 2143 | if (node == _unlinked[i]) {
|
| 2144 | _unlinked.SwapRemove(i);
|
| 2145 | break;
|
| 2146 | }
|
| 2147 | }
|
| 2148 | }
|
| 2149 |
|
Martinsh Shaiters | a9d42b0 | 2013-01-30 11:14:27 +0200 | [diff] [blame] | 2150 | void XMLDocument::Clear()
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 2151 | {
|
Martinsh Shaiters | a9d42b0 | 2013-01-30 11:14:27 +0200 | [diff] [blame] | 2152 | DeleteChildren();
|
Lee Thomason | 816d3fa | 2017-06-05 14:35:55 -0700 | [diff] [blame] | 2153 | while( _unlinked.Size()) {
|
| 2154 | DeleteNode(_unlinked[0]); // Will remove from _unlinked as part of delete.
|
| 2155 | }
|
Martinsh Shaiters | a9d42b0 | 2013-01-30 11:14:27 +0200 | [diff] [blame] | 2156 |
|
Peter Matula | 5068991 | 2018-01-09 12:52:26 +0100 | [diff] [blame] | 2157 | #ifdef TINYXML2_DEBUG
|
Dmitry-Me | ab37df8 | 2014-11-28 12:08:36 +0300 | [diff] [blame] | 2158 | const bool hadError = Error();
|
| 2159 | #endif
|
Dmitry-Me | 0d2cef0 | 2016-11-25 18:39:52 +0300 | [diff] [blame] | 2160 | ClearError();
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 2161 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2162 | delete [] _charBuffer;
|
| 2163 | _charBuffer = 0;
|
Lee Thomason | d946dda | 2018-04-05 09:11:08 -0700 | [diff] [blame] | 2164 | _parsingDepth = 0;
|
Lee Thomason | f07b952 | 2014-10-30 13:25:12 -0700 | [diff] [blame] | 2165 |
|
| 2166 | #if 0
|
| 2167 | _textPool.Trace( "text" );
|
| 2168 | _elementPool.Trace( "element" );
|
| 2169 | _commentPool.Trace( "comment" );
|
| 2170 | _attributePool.Trace( "attribute" );
|
| 2171 | #endif
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 2172 |
|
Peter Matula | 5068991 | 2018-01-09 12:52:26 +0100 | [diff] [blame] | 2173 | #ifdef TINYXML2_DEBUG
|
Dmitry-Me | ab37df8 | 2014-11-28 12:08:36 +0300 | [diff] [blame] | 2174 | if ( !hadError ) {
|
Lee Thomason | f07b952 | 2014-10-30 13:25:12 -0700 | [diff] [blame] | 2175 | TIXMLASSERT( _elementPool.CurrentAllocs() == _elementPool.Untracked() );
|
| 2176 | TIXMLASSERT( _attributePool.CurrentAllocs() == _attributePool.Untracked() );
|
| 2177 | TIXMLASSERT( _textPool.CurrentAllocs() == _textPool.Untracked() );
|
| 2178 | TIXMLASSERT( _commentPool.CurrentAllocs() == _commentPool.Untracked() );
|
| 2179 | }
|
| 2180 | #endif
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 2181 | }
|
| 2182 |
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 2183 |
|
Shuichiro Suzuki | 87cd4e0 | 2017-08-24 11:20:26 +0900 | [diff] [blame] | 2184 | void XMLDocument::DeepCopy(XMLDocument* target) const
|
Lee Thomason | 7085f00 | 2017-06-01 18:09:43 -0700 | [diff] [blame] | 2185 | {
|
| 2186 | TIXMLASSERT(target);
|
Lee Thomason | 1346a17 | 2017-06-14 15:14:19 -0700 | [diff] [blame] | 2187 | if (target == this) {
|
| 2188 | return; // technically success - a no-op.
|
| 2189 | }
|
Lee Thomason | 7085f00 | 2017-06-01 18:09:43 -0700 | [diff] [blame] | 2190 |
|
| 2191 | target->Clear();
|
| 2192 | for (const XMLNode* node = this->FirstChild(); node; node = node->NextSibling()) {
|
| 2193 | target->InsertEndChild(node->DeepClone(target));
|
| 2194 | }
|
| 2195 | }
|
| 2196 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame] | 2197 | XMLElement* XMLDocument::NewElement( const char* name )
|
| 2198 | {
|
Dmitry-Me | 2aebfb7 | 2017-02-27 15:53:40 +0300 | [diff] [blame] | 2199 | XMLElement* ele = CreateUnlinkedNode<XMLElement>( _elementPool );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2200 | ele->SetName( name );
|
| 2201 | return ele;
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame] | 2202 | }
|
| 2203 |
|
| 2204 |
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 2205 | XMLComment* XMLDocument::NewComment( const char* str )
|
| 2206 | {
|
Dmitry-Me | 2aebfb7 | 2017-02-27 15:53:40 +0300 | [diff] [blame] | 2207 | XMLComment* comment = CreateUnlinkedNode<XMLComment>( _commentPool );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2208 | comment->SetValue( str );
|
| 2209 | return comment;
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 2210 | }
|
| 2211 |
|
| 2212 |
|
| 2213 | XMLText* XMLDocument::NewText( const char* str )
|
| 2214 | {
|
Dmitry-Me | 2aebfb7 | 2017-02-27 15:53:40 +0300 | [diff] [blame] | 2215 | XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2216 | text->SetValue( str );
|
| 2217 | return text;
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 2218 | }
|
| 2219 |
|
| 2220 |
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2221 | XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
|
| 2222 | {
|
Dmitry-Me | 2aebfb7 | 2017-02-27 15:53:40 +0300 | [diff] [blame] | 2223 | XMLDeclaration* dec = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2224 | dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );
|
| 2225 | return dec;
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2226 | }
|
| 2227 |
|
| 2228 |
|
| 2229 | XMLUnknown* XMLDocument::NewUnknown( const char* str )
|
| 2230 | {
|
Dmitry-Me | 2aebfb7 | 2017-02-27 15:53:40 +0300 | [diff] [blame] | 2231 | XMLUnknown* unk = CreateUnlinkedNode<XMLUnknown>( _commentPool );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2232 | unk->SetValue( str );
|
| 2233 | return unk;
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2234 | }
|
| 2235 |
|
Dmitry-Me | 01578db | 2014-08-19 10:18:48 +0400 | [diff] [blame] | 2236 | static FILE* callfopen( const char* filepath, const char* mode )
|
| 2237 | {
|
Dmitry-Me | abb2d04 | 2014-12-09 12:59:31 +0300 | [diff] [blame] | 2238 | TIXMLASSERT( filepath );
|
| 2239 | TIXMLASSERT( mode );
|
Dmitry-Me | 01578db | 2014-08-19 10:18:48 +0400 | [diff] [blame] | 2240 | #if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
|
| 2241 | FILE* fp = 0;
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 2242 | const errno_t err = fopen_s( &fp, filepath, mode );
|
Dmitry-Me | 01578db | 2014-08-19 10:18:48 +0400 | [diff] [blame] | 2243 | if ( err ) {
|
| 2244 | return 0;
|
| 2245 | }
|
| 2246 | #else
|
| 2247 | FILE* fp = fopen( filepath, mode );
|
| 2248 | #endif
|
| 2249 | return fp;
|
| 2250 | }
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 2251 |
|
Lee Thomason | cd011bc | 2014-12-17 10:41:34 -0800 | [diff] [blame] | 2252 | void XMLDocument::DeleteNode( XMLNode* node ) {
|
| 2253 | TIXMLASSERT( node );
|
| 2254 | TIXMLASSERT(node->_document == this );
|
| 2255 | if (node->_parent) {
|
| 2256 | node->_parent->DeleteChild( node );
|
| 2257 | }
|
| 2258 | else {
|
| 2259 | // Isn't in the tree.
|
| 2260 | // Use the parent delete.
|
| 2261 | // Also, we need to mark it tracked: we 'know'
|
| 2262 | // it was never used.
|
| 2263 | node->_memPool->SetTracked();
|
| 2264 | // Call the static XMLNode version:
|
| 2265 | XMLNode::DeleteNode(node);
|
| 2266 | }
|
| 2267 | }
|
| 2268 |
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2269 |
|
Lee Thomason | 2fa8172 | 2012-11-09 12:37:46 -0800 | [diff] [blame] | 2270 | XMLError XMLDocument::LoadFile( const char* filename )
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2271 | {
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 2272 | if ( !filename ) {
|
| 2273 | TIXMLASSERT( false );
|
| 2274 | SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
|
| 2275 | return _errorID;
|
| 2276 | }
|
| 2277 |
|
Martinsh Shaiters | a9d42b0 | 2013-01-30 11:14:27 +0200 | [diff] [blame] | 2278 | Clear();
|
Dmitry-Me | 01578db | 2014-08-19 10:18:48 +0400 | [diff] [blame] | 2279 | FILE* fp = callfopen( filename, "rb" );
|
| 2280 | if ( !fp ) {
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 2281 | SetError( XML_ERROR_FILE_NOT_FOUND, 0, "filename=%s", filename );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2282 | return _errorID;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2283 | }
|
| 2284 | LoadFile( fp );
|
| 2285 | fclose( fp );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2286 | return _errorID;
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2287 | }
|
| 2288 |
|
Dmitry-Me | 901fed5 | 2015-09-25 10:29:51 +0300 | [diff] [blame] | 2289 | // This is likely overengineered template art to have a check that unsigned long value incremented
|
| 2290 | // by one still fits into size_t. If size_t type is larger than unsigned long type
|
| 2291 | // (x86_64-w64-mingw32 target) then the check is redundant and gcc and clang emit
|
| 2292 | // -Wtype-limits warning. This piece makes the compiler select code with a check when a check
|
| 2293 | // is useful and code with no check when a check is redundant depending on how size_t and unsigned long
|
| 2294 | // types sizes relate to each other.
|
| 2295 | template
|
| 2296 | <bool = (sizeof(unsigned long) >= sizeof(size_t))>
|
| 2297 | struct LongFitsIntoSizeTMinusOne {
|
| 2298 | static bool Fits( unsigned long value )
|
| 2299 | {
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 2300 | return value < static_cast<size_t>(-1);
|
Dmitry-Me | 901fed5 | 2015-09-25 10:29:51 +0300 | [diff] [blame] | 2301 | }
|
| 2302 | };
|
| 2303 |
|
| 2304 | template <>
|
Manlio Morini | 0f45b24 | 2016-07-11 12:14:59 +0200 | [diff] [blame] | 2305 | struct LongFitsIntoSizeTMinusOne<false> {
|
| 2306 | static bool Fits( unsigned long )
|
| 2307 | {
|
| 2308 | return true;
|
| 2309 | }
|
| 2310 | };
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2311 |
|
Lee Thomason | 2fa8172 | 2012-11-09 12:37:46 -0800 | [diff] [blame] | 2312 | XMLError XMLDocument::LoadFile( FILE* fp )
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2313 | {
|
Martinsh Shaiters | a9d42b0 | 2013-01-30 11:14:27 +0200 | [diff] [blame] | 2314 | Clear();
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2315 |
|
Daniel Marjamäki | ba4b328 | 2014-01-10 21:37:27 +0100 | [diff] [blame] | 2316 | fseek( fp, 0, SEEK_SET );
|
Dmitry-Me | 08e7f7b | 2014-07-31 15:19:14 +0400 | [diff] [blame] | 2317 | if ( fgetc( fp ) == EOF && ferror( fp ) != 0 ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2318 | SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
|
Daniel Marjamäki | ba4b328 | 2014-01-10 21:37:27 +0100 | [diff] [blame] | 2319 | return _errorID;
|
| 2320 | }
|
| 2321 |
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2322 | fseek( fp, 0, SEEK_END );
|
Dmitry-Me | acb9c9c | 2014-08-04 09:49:25 +0400 | [diff] [blame] | 2323 | const long filelength = ftell( fp );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2324 | fseek( fp, 0, SEEK_SET );
|
Dmitry-Me | acb9c9c | 2014-08-04 09:49:25 +0400 | [diff] [blame] | 2325 | if ( filelength == -1L ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2326 | SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
|
Dmitry-Me | acb9c9c | 2014-08-04 09:49:25 +0400 | [diff] [blame] | 2327 | return _errorID;
|
| 2328 | }
|
Dmitry-Me | 96b110d | 2016-02-09 15:12:40 +0300 | [diff] [blame] | 2329 | TIXMLASSERT( filelength >= 0 );
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2330 |
|
Dmitry-Me | 901fed5 | 2015-09-25 10:29:51 +0300 | [diff] [blame] | 2331 | if ( !LongFitsIntoSizeTMinusOne<>::Fits( filelength ) ) {
|
Dmitry-Me | 2a8b1f5 | 2015-04-30 14:58:57 +0300 | [diff] [blame] | 2332 | // Cannot handle files which won't fit in buffer together with null terminator
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2333 | SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
|
Dmitry-Me | 2a8b1f5 | 2015-04-30 14:58:57 +0300 | [diff] [blame] | 2334 | return _errorID;
|
| 2335 | }
|
| 2336 |
|
Dmitry-Me | 72801b8 | 2015-05-07 09:41:39 +0300 | [diff] [blame] | 2337 | if ( filelength == 0 ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2338 | SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2339 | return _errorID;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2340 | }
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 2341 |
|
Dmitry-Me | 72801b8 | 2015-05-07 09:41:39 +0300 | [diff] [blame] | 2342 | const size_t size = filelength;
|
Dmitry-Me | 96f38cc | 2015-08-10 16:45:12 +0300 | [diff] [blame] | 2343 | TIXMLASSERT( _charBuffer == 0 );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2344 | _charBuffer = new char[size+1];
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 2345 | const size_t read = fread( _charBuffer, 1, size, fp );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2346 | if ( read != size ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2347 | SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2348 | return _errorID;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2349 | }
|
Lee Thomason (grinliz) | 2f1f624 | 2012-09-16 11:32:34 -0700 | [diff] [blame] | 2350 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2351 | _charBuffer[size] = 0;
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2352 |
|
Dmitry-Me | 97476b7 | 2015-01-01 16:15:57 +0300 | [diff] [blame] | 2353 | Parse();
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2354 | return _errorID;
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2355 | }
|
| 2356 |
|
| 2357 |
|
Lee Thomason | 2fa8172 | 2012-11-09 12:37:46 -0800 | [diff] [blame] | 2358 | XMLError XMLDocument::SaveFile( const char* filename, bool compact )
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2359 | {
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 2360 | if ( !filename ) {
|
| 2361 | TIXMLASSERT( false );
|
| 2362 | SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
|
| 2363 | return _errorID;
|
| 2364 | }
|
| 2365 |
|
Dmitry-Me | 01578db | 2014-08-19 10:18:48 +0400 | [diff] [blame] | 2366 | FILE* fp = callfopen( filename, "w" );
|
| 2367 | if ( !fp ) {
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 2368 | SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=%s", filename );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2369 | return _errorID;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2370 | }
|
| 2371 | SaveFile(fp, compact);
|
| 2372 | fclose( fp );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2373 | return _errorID;
|
Ken Miller | 81da1fb | 2012-04-09 23:32:26 -0500 | [diff] [blame] | 2374 | }
|
| 2375 |
|
| 2376 |
|
Lee Thomason | 2fa8172 | 2012-11-09 12:37:46 -0800 | [diff] [blame] | 2377 | XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
|
Ken Miller | 81da1fb | 2012-04-09 23:32:26 -0500 | [diff] [blame] | 2378 | {
|
Ant Mitchell | 189198f | 2015-03-24 16:20:36 +0000 | [diff] [blame] | 2379 | // Clear any error from the last save, otherwise it will get reported
|
| 2380 | // for *this* call.
|
Dmitry-Me | 0d2cef0 | 2016-11-25 18:39:52 +0300 | [diff] [blame] | 2381 | ClearError();
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2382 | XMLPrinter stream( fp, compact );
|
| 2383 | Print( &stream );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2384 | return _errorID;
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2385 | }
|
| 2386 |
|
Lee Thomason | 1ff38e0 | 2012-02-14 18:18:16 -0800 | [diff] [blame] | 2387 |
|
Lee Thomason | 2fa8172 | 2012-11-09 12:37:46 -0800 | [diff] [blame] | 2388 | XMLError XMLDocument::Parse( const char* p, size_t len )
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 2389 | {
|
Martinsh Shaiters | a9d42b0 | 2013-01-30 11:14:27 +0200 | [diff] [blame] | 2390 | Clear();
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 2391 |
|
Lee Thomason | 82d3200 | 2014-02-21 22:47:18 -0800 | [diff] [blame] | 2392 | if ( len == 0 || !p || !*p ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2393 | SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2394 | return _errorID;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2395 | }
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 2396 | if ( len == static_cast<size_t>(-1) ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2397 | len = strlen( p );
|
| 2398 | }
|
Dmitry-Me | 96f38cc | 2015-08-10 16:45:12 +0300 | [diff] [blame] | 2399 | TIXMLASSERT( _charBuffer == 0 );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2400 | _charBuffer = new char[ len+1 ];
|
| 2401 | memcpy( _charBuffer, p, len );
|
| 2402 | _charBuffer[len] = 0;
|
Lee Thomason (grinliz) | e2bcb32 | 2012-09-17 17:58:25 -0700 | [diff] [blame] | 2403 |
|
Dmitry-Me | 97476b7 | 2015-01-01 16:15:57 +0300 | [diff] [blame] | 2404 | Parse();
|
Dmitry-Me | 9bcd9c7 | 2014-12-09 10:58:14 +0300 | [diff] [blame] | 2405 | if ( Error() ) {
|
Lee Thomason | f07b952 | 2014-10-30 13:25:12 -0700 | [diff] [blame] | 2406 | // clean up now essentially dangling memory.
|
| 2407 | // and the parse fail can put objects in the
|
| 2408 | // pools that are dead and inaccessible.
|
| 2409 | DeleteChildren();
|
| 2410 | _elementPool.Clear();
|
| 2411 | _attributePool.Clear();
|
| 2412 | _textPool.Clear();
|
| 2413 | _commentPool.Clear();
|
| 2414 | }
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2415 | return _errorID;
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 2416 | }
|
| 2417 |
|
| 2418 |
|
PKEuS | 1c5f99e | 2013-07-06 11:28:39 +0200 | [diff] [blame] | 2419 | void XMLDocument::Print( XMLPrinter* streamer ) const
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 2420 | {
|
Dmitry-Me | 67c429e | 2015-05-08 18:08:18 +0300 | [diff] [blame] | 2421 | if ( streamer ) {
|
| 2422 | Accept( streamer );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2423 | }
|
Dmitry-Me | 67c429e | 2015-05-08 18:08:18 +0300 | [diff] [blame] | 2424 | else {
|
| 2425 | XMLPrinter stdoutStreamer( stdout );
|
| 2426 | Accept( &stdoutStreamer );
|
| 2427 | }
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 2428 | }
|
| 2429 |
|
| 2430 |
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2431 | void XMLDocument::SetError( XMLError error, int lineNum, const char* format, ... )
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 2432 | {
|
Dmitry-Me | 66d2a84 | 2014-11-08 15:24:52 +0300 | [diff] [blame] | 2433 | TIXMLASSERT( error >= 0 && error < XML_ERROR_COUNT );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2434 | _errorID = error;
|
Lee Thomason | 714ccfe | 2017-10-10 17:08:12 -0700 | [diff] [blame] | 2435 | _errorLineNum = lineNum;
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2436 | _errorStr.Reset();
|
Lee Thomason | 584af57 | 2016-09-05 14:14:16 -0700 | [diff] [blame] | 2437 |
|
orbitcowboy | 0e7f289 | 2019-01-15 11:28:49 +0100 | [diff] [blame] | 2438 | const size_t BUFFER_SIZE = 1000;
|
Lee Thomason | a36f7ac | 2017-12-28 13:48:54 -0800 | [diff] [blame] | 2439 | char* buffer = new char[BUFFER_SIZE];
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2440 |
|
Lee Thomason | 30d0c3d | 2018-06-29 15:47:37 -0700 | [diff] [blame] | 2441 | TIXMLASSERT(sizeof(error) <= sizeof(int));
|
Lee Thomason | a36f7ac | 2017-12-28 13:48:54 -0800 | [diff] [blame] | 2442 | TIXML_SNPRINTF(buffer, BUFFER_SIZE, "Error=%s ErrorID=%d (0x%x) Line number=%d", ErrorIDToName(error), int(error), int(error), lineNum);
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2443 |
|
Lee Thomason | a36f7ac | 2017-12-28 13:48:54 -0800 | [diff] [blame] | 2444 | if (format) {
|
| 2445 | size_t len = strlen(buffer);
|
| 2446 | TIXML_SNPRINTF(buffer + len, BUFFER_SIZE - len, ": ");
|
| 2447 | len = strlen(buffer);
|
| 2448 |
|
| 2449 | va_list va;
|
| 2450 | va_start(va, format);
|
| 2451 | TIXML_VSNPRINTF(buffer + len, BUFFER_SIZE - len, format, va);
|
| 2452 | va_end(va);
|
| 2453 | }
|
| 2454 | _errorStr.SetStr(buffer);
|
| 2455 | delete[] buffer;
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 2456 | }
|
| 2457 |
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2458 |
|
Lee Thomason | e90e901 | 2016-12-24 07:34:39 -0800 | [diff] [blame] | 2459 | /*static*/ const char* XMLDocument::ErrorIDToName(XMLError errorID)
|
Lee Thomason | 331596e | 2014-09-11 14:56:43 -0700 | [diff] [blame] | 2460 | {
|
kezenator | 5a70071 | 2016-11-26 13:54:42 +1000 | [diff] [blame] | 2461 | TIXMLASSERT( errorID >= 0 && errorID < XML_ERROR_COUNT );
|
| 2462 | const char* errorName = _errorNames[errorID];
|
Dmitry-Me | a1beddf | 2015-05-26 16:19:21 +0300 | [diff] [blame] | 2463 | TIXMLASSERT( errorName && errorName[0] );
|
| 2464 | return errorName;
|
Lee Thomason | 331596e | 2014-09-11 14:56:43 -0700 | [diff] [blame] | 2465 | }
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2466 |
|
Gumichan01 | 0f1fa6d | 2018-02-01 14:16:24 +0100 | [diff] [blame] | 2467 | const char* XMLDocument::ErrorStr() const
|
Lee Thomason | 8c9e313 | 2017-06-26 16:55:01 -0700 | [diff] [blame] | 2468 | {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2469 | return _errorStr.Empty() ? "" : _errorStr.GetStr();
|
Lee Thomason | 8c9e313 | 2017-06-26 16:55:01 -0700 | [diff] [blame] | 2470 | }
|
| 2471 |
|
Lee Thomason | f49b965 | 2017-10-11 10:57:49 -0700 | [diff] [blame] | 2472 |
|
| 2473 | void XMLDocument::PrintError() const
|
| 2474 | {
|
| 2475 | printf("%s\n", ErrorStr());
|
| 2476 | }
|
| 2477 |
|
kezenator | 5a70071 | 2016-11-26 13:54:42 +1000 | [diff] [blame] | 2478 | const char* XMLDocument::ErrorName() const
|
| 2479 | {
|
Lee Thomason | e90e901 | 2016-12-24 07:34:39 -0800 | [diff] [blame] | 2480 | return ErrorIDToName(_errorID);
|
kezenator | 5a70071 | 2016-11-26 13:54:42 +1000 | [diff] [blame] | 2481 | }
|
| 2482 |
|
Dmitry-Me | 97476b7 | 2015-01-01 16:15:57 +0300 | [diff] [blame] | 2483 | void XMLDocument::Parse()
|
| 2484 | {
|
| 2485 | TIXMLASSERT( NoChildren() ); // Clear() must have been called previously
|
| 2486 | TIXMLASSERT( _charBuffer );
|
kezenator | ec69415 | 2016-11-26 17:21:43 +1000 | [diff] [blame] | 2487 | _parseCurLineNum = 1;
|
| 2488 | _parseLineNum = 1;
|
Lee Thomason | 3cebdc4 | 2015-01-05 17:16:28 -0800 | [diff] [blame] | 2489 | char* p = _charBuffer;
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 2490 | p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
|
Dmitry-Me | e28be75 | 2015-01-09 14:59:30 +0300 | [diff] [blame] | 2491 | p = const_cast<char*>( XMLUtil::ReadBOM( p, &_writeBOM ) );
|
Dmitry-Me | 97476b7 | 2015-01-01 16:15:57 +0300 | [diff] [blame] | 2492 | if ( !*p ) {
|
Lee Thomason | aa18839 | 2017-09-19 17:54:31 -0700 | [diff] [blame] | 2493 | SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
|
Dmitry-Me | 97476b7 | 2015-01-01 16:15:57 +0300 | [diff] [blame] | 2494 | return;
|
| 2495 | }
|
kezenator | 4f75616 | 2016-11-29 19:46:27 +1000 | [diff] [blame] | 2496 | ParseDeep(p, 0, &_parseCurLineNum );
|
Dmitry-Me | 97476b7 | 2015-01-01 16:15:57 +0300 | [diff] [blame] | 2497 | }
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2498 |
|
Lee Thomason | f928c35 | 2018-04-05 09:24:20 -0700 | [diff] [blame] | 2499 | void XMLDocument::PushDepth()
|
Lee Thomason | d946dda | 2018-04-05 09:11:08 -0700 | [diff] [blame] | 2500 | {
|
| 2501 | _parsingDepth++;
|
| 2502 | if (_parsingDepth == TINYXML2_MAX_ELEMENT_DEPTH) {
|
Lee Thomason | befc3c3 | 2018-04-05 15:53:14 -0700 | [diff] [blame] | 2503 | SetError(XML_ELEMENT_DEPTH_EXCEEDED, _parseCurLineNum, "Element nesting is too deep." );
|
Lee Thomason | d946dda | 2018-04-05 09:11:08 -0700 | [diff] [blame] | 2504 | }
|
Lee Thomason | d946dda | 2018-04-05 09:11:08 -0700 | [diff] [blame] | 2505 | }
|
| 2506 |
|
Lee Thomason | f928c35 | 2018-04-05 09:24:20 -0700 | [diff] [blame] | 2507 | void XMLDocument::PopDepth()
|
Lee Thomason | d946dda | 2018-04-05 09:11:08 -0700 | [diff] [blame] | 2508 | {
|
| 2509 | TIXMLASSERT(_parsingDepth > 0);
|
| 2510 | --_parsingDepth;
|
Lee Thomason | d946dda | 2018-04-05 09:11:08 -0700 | [diff] [blame] | 2511 | }
|
| 2512 |
|
PKEuS | 1bfb954 | 2013-08-04 13:51:17 +0200 | [diff] [blame] | 2513 | XMLPrinter::XMLPrinter( FILE* file, bool compact, int depth ) :
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2514 | _elementJustOpened( false ),
|
Thierry Lelegard | 7f0f754 | 2017-09-01 10:14:16 +0200 | [diff] [blame] | 2515 | _stack(),
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2516 | _firstElement( true ),
|
| 2517 | _fp( file ),
|
PKEuS | 1bfb954 | 2013-08-04 13:51:17 +0200 | [diff] [blame] | 2518 | _depth( depth ),
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2519 | _textDepth( -1 ),
|
| 2520 | _processEntities( true ),
|
Thierry Lelegard | 7f0f754 | 2017-09-01 10:14:16 +0200 | [diff] [blame] | 2521 | _compactMode( compact ),
|
| 2522 | _buffer()
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2523 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2524 | for( int i=0; i<ENTITY_RANGE; ++i ) {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2525 | _entityFlag[i] = false;
|
| 2526 | _restrictedEntityFlag[i] = false;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2527 | }
|
| 2528 | for( int i=0; i<NUM_ENTITIES; ++i ) {
|
Dmitry-Me | 8b67d74 | 2014-12-22 11:35:12 +0300 | [diff] [blame] | 2529 | const char entityValue = entities[i].value;
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 2530 | const unsigned char flagIndex = static_cast<unsigned char>(entityValue);
|
Dmitry-Me | a28eb07 | 2017-08-25 18:34:18 +0300 | [diff] [blame] | 2531 | TIXMLASSERT( flagIndex < ENTITY_RANGE );
|
| 2532 | _entityFlag[flagIndex] = true;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2533 | }
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 2534 | _restrictedEntityFlag[static_cast<unsigned char>('&')] = true;
|
| 2535 | _restrictedEntityFlag[static_cast<unsigned char>('<')] = true;
|
| 2536 | _restrictedEntityFlag[static_cast<unsigned char>('>')] = true; // not required, but consistency is nice
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2537 | _buffer.Push( 0 );
|
U-Stream\Lee | ae25a44 | 2012-02-17 17:48:16 -0800 | [diff] [blame] | 2538 | }
|
| 2539 |
|
| 2540 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2541 | void XMLPrinter::Print( const char* format, ... )
|
U-Stream\Lee | ae25a44 | 2012-02-17 17:48:16 -0800 | [diff] [blame] | 2542 | {
|
| 2543 | va_list va;
|
| 2544 | va_start( va, format );
|
| 2545 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2546 | if ( _fp ) {
|
| 2547 | vfprintf( _fp, format, va );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2548 | }
|
| 2549 | else {
|
Dmitry-Me | 1d32e58 | 2015-07-27 17:11:51 +0300 | [diff] [blame] | 2550 | const int len = TIXML_VSCPRINTF( format, va );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2551 | // Close out and re-start the va-args
|
| 2552 | va_end( va );
|
Dmitry-Me | 1d32e58 | 2015-07-27 17:11:51 +0300 | [diff] [blame] | 2553 | TIXMLASSERT( len >= 0 );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2554 | va_start( va, format );
|
Dmitry-Me | 30bdc97 | 2015-01-14 08:32:23 +0300 | [diff] [blame] | 2555 | TIXMLASSERT( _buffer.Size() > 0 && _buffer[_buffer.Size() - 1] == 0 );
|
Lee Thomason | a0744c8 | 2014-03-16 10:32:27 -0700 | [diff] [blame] | 2556 | char* p = _buffer.PushArr( len ) - 1; // back up over the null terminator.
|
pffang | 1527cf4 | 2015-06-09 13:57:11 +0800 | [diff] [blame] | 2557 | TIXML_VSNPRINTF( p, len+1, format, va );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2558 | }
|
U-Stream\Lee | ae25a44 | 2012-02-17 17:48:16 -0800 | [diff] [blame] | 2559 | va_end( va );
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2560 | }
|
| 2561 |
|
| 2562 |
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2563 | void XMLPrinter::Write( const char* data, size_t size )
|
| 2564 | {
|
| 2565 | if ( _fp ) {
|
| 2566 | fwrite ( data , sizeof(char), size, _fp);
|
| 2567 | }
|
| 2568 | else {
|
Alex Alabuzhev | 90e69c9 | 2017-11-09 00:32:19 +0000 | [diff] [blame] | 2569 | char* p = _buffer.PushArr( static_cast<int>(size) ) - 1; // back up over the null terminator.
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2570 | memcpy( p, data, size );
|
| 2571 | p[size] = 0;
|
| 2572 | }
|
| 2573 | }
|
| 2574 |
|
| 2575 |
|
| 2576 | void XMLPrinter::Putc( char ch )
|
| 2577 | {
|
| 2578 | if ( _fp ) {
|
| 2579 | fputc ( ch, _fp);
|
| 2580 | }
|
| 2581 | else {
|
| 2582 | char* p = _buffer.PushArr( sizeof(char) ) - 1; // back up over the null terminator.
|
| 2583 | p[0] = ch;
|
| 2584 | p[1] = 0;
|
| 2585 | }
|
| 2586 | }
|
| 2587 |
|
| 2588 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2589 | void XMLPrinter::PrintSpace( int depth )
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2590 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2591 | for( int i=0; i<depth; ++i ) {
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2592 | Write( " " );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2593 | }
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2594 | }
|
| 2595 |
|
| 2596 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2597 | void XMLPrinter::PrintString( const char* p, bool restricted )
|
Lee Thomason | 857b868 | 2012-01-25 17:50:25 -0800 | [diff] [blame] | 2598 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2599 | // Look for runs of bytes between entities to print.
|
| 2600 | const char* q = p;
|
Lee Thomason | 857b868 | 2012-01-25 17:50:25 -0800 | [diff] [blame] | 2601 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2602 | if ( _processEntities ) {
|
Dmitry-Me | 6acc9a5 | 2015-01-15 13:27:47 +0300 | [diff] [blame] | 2603 | const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2604 | while ( *q ) {
|
Dmitry-Me | 69d521d | 2015-04-20 18:05:53 +0300 | [diff] [blame] | 2605 | TIXMLASSERT( p <= q );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2606 | // Remember, char is sometimes signed. (How many times has that bitten me?)
|
| 2607 | if ( *q > 0 && *q < ENTITY_RANGE ) {
|
| 2608 | // Check for entities. If one is found, flush
|
| 2609 | // the stream up until the entity, write the
|
| 2610 | // entity, and keep looking.
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 2611 | if ( flag[static_cast<unsigned char>(*q)] ) {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2612 | while ( p < q ) {
|
Dmitry-Me | d95172b | 2015-03-30 08:11:18 +0300 | [diff] [blame] | 2613 | const size_t delta = q - p;
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 2614 | const int toPrint = ( INT_MAX < delta ) ? INT_MAX : static_cast<int>(delta);
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2615 | Write( p, toPrint );
|
Dmitry-Me | d95172b | 2015-03-30 08:11:18 +0300 | [diff] [blame] | 2616 | p += toPrint;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2617 | }
|
Dmitry-Me | 39c399a | 2015-05-28 15:32:27 +0300 | [diff] [blame] | 2618 | bool entityPatternPrinted = false;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2619 | for( int i=0; i<NUM_ENTITIES; ++i ) {
|
| 2620 | if ( entities[i].value == *q ) {
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2621 | Putc( '&' );
|
Brad Anderson | 85aac02 | 2017-10-24 21:48:28 -0600 | [diff] [blame] | 2622 | Write( entities[i].pattern, entities[i].length );
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2623 | Putc( ';' );
|
Dmitry-Me | 39c399a | 2015-05-28 15:32:27 +0300 | [diff] [blame] | 2624 | entityPatternPrinted = true;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2625 | break;
|
| 2626 | }
|
| 2627 | }
|
Dmitry-Me | 39c399a | 2015-05-28 15:32:27 +0300 | [diff] [blame] | 2628 | if ( !entityPatternPrinted ) {
|
| 2629 | // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release
|
| 2630 | TIXMLASSERT( false );
|
| 2631 | }
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2632 | ++p;
|
| 2633 | }
|
| 2634 | }
|
| 2635 | ++q;
|
Dmitry-Me | 69d521d | 2015-04-20 18:05:53 +0300 | [diff] [blame] | 2636 | TIXMLASSERT( p <= q );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2637 | }
|
Derek Quam | be69ae6 | 2018-04-18 13:40:46 -0500 | [diff] [blame] | 2638 | // Flush the remaining string. This will be the entire
|
| 2639 | // string if an entity wasn't found.
|
| 2640 | if ( p < q ) {
|
| 2641 | const size_t delta = q - p;
|
orbitcowboy | 710a332 | 2019-05-16 15:30:47 +0200 | [diff] [blame] | 2642 | const int toPrint = ( INT_MAX < delta ) ? INT_MAX : static_cast<int>(delta);
|
Derek Quam | be69ae6 | 2018-04-18 13:40:46 -0500 | [diff] [blame] | 2643 | Write( p, toPrint );
|
| 2644 | }
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2645 | }
|
Derek Quam | be69ae6 | 2018-04-18 13:40:46 -0500 | [diff] [blame] | 2646 | else {
|
| 2647 | Write( p );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2648 | }
|
Lee Thomason | 857b868 | 2012-01-25 17:50:25 -0800 | [diff] [blame] | 2649 | }
|
| 2650 |
|
U-Stream\Lee | ae25a44 | 2012-02-17 17:48:16 -0800 | [diff] [blame] | 2651 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2652 | void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 2653 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2654 | if ( writeBOM ) {
|
PKEuS | 1bfb954 | 2013-08-04 13:51:17 +0200 | [diff] [blame] | 2655 | static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2656 | Write( reinterpret_cast< const char* >( bom ) );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2657 | }
|
| 2658 | if ( writeDec ) {
|
| 2659 | PushDeclaration( "xml version=\"1.0\"" );
|
| 2660 | }
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 2661 | }
|
| 2662 |
|
| 2663 |
|
Uli Kusterer | 593a33d | 2014-02-01 12:48:51 +0100 | [diff] [blame] | 2664 | void XMLPrinter::OpenElement( const char* name, bool compactMode )
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2665 | {
|
Dmitry-Me | a092bc1 | 2014-12-23 17:57:05 +0300 | [diff] [blame] | 2666 | SealElementIfJustOpened();
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2667 | _stack.Push( name );
|
Lee Thomason | 56bdd02 | 2012-02-09 18:16:58 -0800 | [diff] [blame] | 2668 |
|
Uli Kusterer | 593a33d | 2014-02-01 12:48:51 +0100 | [diff] [blame] | 2669 | if ( _textDepth < 0 && !_firstElement && !compactMode ) {
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2670 | Putc( '\n' );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2671 | PrintSpace( _depth );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2672 | }
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2673 |
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2674 | Write ( "<" );
|
| 2675 | Write ( name );
|
| 2676 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2677 | _elementJustOpened = true;
|
| 2678 | _firstElement = false;
|
| 2679 | ++_depth;
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2680 | }
|
| 2681 |
|
| 2682 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2683 | void XMLPrinter::PushAttribute( const char* name, const char* value )
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2684 | {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2685 | TIXMLASSERT( _elementJustOpened );
|
Brad Anderson | 85aac02 | 2017-10-24 21:48:28 -0600 | [diff] [blame] | 2686 | Putc ( ' ' );
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2687 | Write( name );
|
| 2688 | Write( "=\"" );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2689 | PrintString( value, false );
|
Brad Anderson | 85aac02 | 2017-10-24 21:48:28 -0600 | [diff] [blame] | 2690 | Putc ( '\"' );
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2691 | }
|
| 2692 |
|
| 2693 |
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2694 | void XMLPrinter::PushAttribute( const char* name, int v )
|
| 2695 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2696 | char buf[BUF_SIZE];
|
| 2697 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
| 2698 | PushAttribute( name, buf );
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2699 | }
|
| 2700 |
|
| 2701 |
|
| 2702 | void XMLPrinter::PushAttribute( const char* name, unsigned v )
|
| 2703 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2704 | char buf[BUF_SIZE];
|
| 2705 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
| 2706 | PushAttribute( name, buf );
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2707 | }
|
| 2708 |
|
| 2709 |
|
Lee Thomason | 51c1271 | 2016-06-04 20:18:49 -0700 | [diff] [blame] | 2710 | void XMLPrinter::PushAttribute(const char* name, int64_t v)
|
| 2711 | {
|
| 2712 | char buf[BUF_SIZE];
|
| 2713 | XMLUtil::ToStr(v, buf, BUF_SIZE);
|
| 2714 | PushAttribute(name, buf);
|
| 2715 | }
|
| 2716 |
|
| 2717 |
|
aaronkirkham07@gmail.com | c341cea | 2019-05-22 00:05:27 +0100 | [diff] [blame] | 2718 | void XMLPrinter::PushAttribute(const char* name, uint64_t v)
|
| 2719 | {
|
| 2720 | char buf[BUF_SIZE];
|
| 2721 | XMLUtil::ToStr(v, buf, BUF_SIZE);
|
| 2722 | PushAttribute(name, buf);
|
| 2723 | }
|
| 2724 |
|
| 2725 |
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2726 | void XMLPrinter::PushAttribute( const char* name, bool v )
|
| 2727 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2728 | char buf[BUF_SIZE];
|
| 2729 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
| 2730 | PushAttribute( name, buf );
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2731 | }
|
| 2732 |
|
| 2733 |
|
| 2734 | void XMLPrinter::PushAttribute( const char* name, double v )
|
| 2735 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2736 | char buf[BUF_SIZE];
|
| 2737 | XMLUtil::ToStr( v, buf, BUF_SIZE );
|
| 2738 | PushAttribute( name, buf );
|
Lee Thomason | 7d00b9a | 2012-02-27 17:54:22 -0800 | [diff] [blame] | 2739 | }
|
| 2740 |
|
| 2741 |
|
Uli Kusterer | ca412e8 | 2014-02-01 13:35:05 +0100 | [diff] [blame] | 2742 | void XMLPrinter::CloseElement( bool compactMode )
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2743 | {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2744 | --_depth;
|
| 2745 | const char* name = _stack.Pop();
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2746 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2747 | if ( _elementJustOpened ) {
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2748 | Write( "/>" );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2749 | }
|
| 2750 | else {
|
Uli Kusterer | ca412e8 | 2014-02-01 13:35:05 +0100 | [diff] [blame] | 2751 | if ( _textDepth < 0 && !compactMode) {
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2752 | Putc( '\n' );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2753 | PrintSpace( _depth );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2754 | }
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2755 | Write ( "</" );
|
| 2756 | Write ( name );
|
| 2757 | Write ( ">" );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2758 | }
|
Lee Thomason | 56bdd02 | 2012-02-09 18:16:58 -0800 | [diff] [blame] | 2759 |
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2760 | if ( _textDepth == _depth ) {
|
| 2761 | _textDepth = -1;
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2762 | }
|
Uli Kusterer | ca412e8 | 2014-02-01 13:35:05 +0100 | [diff] [blame] | 2763 | if ( _depth == 0 && !compactMode) {
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2764 | Putc( '\n' );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2765 | }
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2766 | _elementJustOpened = false;
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2767 | }
|
| 2768 |
|
| 2769 |
|
Dmitry-Me | a092bc1 | 2014-12-23 17:57:05 +0300 | [diff] [blame] | 2770 | void XMLPrinter::SealElementIfJustOpened()
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2771 | {
|
Dmitry-Me | a092bc1 | 2014-12-23 17:57:05 +0300 | [diff] [blame] | 2772 | if ( !_elementJustOpened ) {
|
| 2773 | return;
|
| 2774 | }
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2775 | _elementJustOpened = false;
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2776 | Putc( '>' );
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2777 | }
|
| 2778 |
|
| 2779 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2780 | void XMLPrinter::PushText( const char* text, bool cdata )
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2781 | {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2782 | _textDepth = _depth-1;
|
Lee Thomason | 56bdd02 | 2012-02-09 18:16:58 -0800 | [diff] [blame] | 2783 |
|
Dmitry-Me | a092bc1 | 2014-12-23 17:57:05 +0300 | [diff] [blame] | 2784 | SealElementIfJustOpened();
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2785 | if ( cdata ) {
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2786 | Write( "<![CDATA[" );
|
| 2787 | Write( text );
|
| 2788 | Write( "]]>" );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2789 | }
|
| 2790 | else {
|
| 2791 | PrintString( text, true );
|
| 2792 | }
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2793 | }
|
| 2794 |
|
aaronkirkham07@gmail.com | c341cea | 2019-05-22 00:05:27 +0100 | [diff] [blame] | 2795 |
|
Stefan Asbeck | e1a82c1 | 2016-08-04 09:12:45 +0200 | [diff] [blame] | 2796 | void XMLPrinter::PushText( int64_t value )
|
| 2797 | {
|
| 2798 | char buf[BUF_SIZE];
|
| 2799 | XMLUtil::ToStr( value, buf, BUF_SIZE );
|
| 2800 | PushText( buf, false );
|
| 2801 | }
|
| 2802 |
|
aaronkirkham07@gmail.com | c341cea | 2019-05-22 00:05:27 +0100 | [diff] [blame] | 2803 |
|
| 2804 | void XMLPrinter::PushText( uint64_t value )
|
| 2805 | {
|
| 2806 | char buf[BUF_SIZE];
|
| 2807 | XMLUtil::ToStr(value, buf, BUF_SIZE);
|
| 2808 | PushText(buf, false);
|
| 2809 | }
|
| 2810 |
|
| 2811 |
|
Lee Thomason (grinliz) | 2f1f624 | 2012-09-16 11:32:34 -0700 | [diff] [blame] | 2812 | void XMLPrinter::PushText( int value )
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 2813 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2814 | char buf[BUF_SIZE];
|
| 2815 | XMLUtil::ToStr( value, buf, BUF_SIZE );
|
| 2816 | PushText( buf, false );
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 2817 | }
|
| 2818 |
|
| 2819 |
|
Lee Thomason (grinliz) | 2f1f624 | 2012-09-16 11:32:34 -0700 | [diff] [blame] | 2820 | void XMLPrinter::PushText( unsigned value )
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 2821 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2822 | char buf[BUF_SIZE];
|
| 2823 | XMLUtil::ToStr( value, buf, BUF_SIZE );
|
| 2824 | PushText( buf, false );
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 2825 | }
|
| 2826 |
|
| 2827 |
|
Lee Thomason (grinliz) | 2f1f624 | 2012-09-16 11:32:34 -0700 | [diff] [blame] | 2828 | void XMLPrinter::PushText( bool value )
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 2829 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2830 | char buf[BUF_SIZE];
|
| 2831 | XMLUtil::ToStr( value, buf, BUF_SIZE );
|
| 2832 | PushText( buf, false );
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 2833 | }
|
| 2834 |
|
| 2835 |
|
Lee Thomason (grinliz) | 2f1f624 | 2012-09-16 11:32:34 -0700 | [diff] [blame] | 2836 | void XMLPrinter::PushText( float value )
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 2837 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2838 | char buf[BUF_SIZE];
|
| 2839 | XMLUtil::ToStr( value, buf, BUF_SIZE );
|
| 2840 | PushText( buf, false );
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 2841 | }
|
| 2842 |
|
| 2843 |
|
Lee Thomason (grinliz) | 2f1f624 | 2012-09-16 11:32:34 -0700 | [diff] [blame] | 2844 | void XMLPrinter::PushText( double value )
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 2845 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2846 | char buf[BUF_SIZE];
|
| 2847 | XMLUtil::ToStr( value, buf, BUF_SIZE );
|
| 2848 | PushText( buf, false );
|
Lee Thomason | 21be882 | 2012-07-15 17:27:22 -0700 | [diff] [blame] | 2849 | }
|
| 2850 |
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2851 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2852 | void XMLPrinter::PushComment( const char* comment )
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2853 | {
|
Dmitry-Me | a092bc1 | 2014-12-23 17:57:05 +0300 | [diff] [blame] | 2854 | SealElementIfJustOpened();
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2855 | if ( _textDepth < 0 && !_firstElement && !_compactMode) {
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2856 | Putc( '\n' );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2857 | PrintSpace( _depth );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2858 | }
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2859 | _firstElement = false;
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2860 |
|
| 2861 | Write( "<!--" );
|
| 2862 | Write( comment );
|
| 2863 | Write( "-->" );
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 2864 | }
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 2865 |
|
| 2866 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2867 | void XMLPrinter::PushDeclaration( const char* value )
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2868 | {
|
Dmitry-Me | a092bc1 | 2014-12-23 17:57:05 +0300 | [diff] [blame] | 2869 | SealElementIfJustOpened();
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2870 | if ( _textDepth < 0 && !_firstElement && !_compactMode) {
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2871 | Putc( '\n' );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2872 | PrintSpace( _depth );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2873 | }
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2874 | _firstElement = false;
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2875 |
|
| 2876 | Write( "<?" );
|
| 2877 | Write( value );
|
| 2878 | Write( "?>" );
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2879 | }
|
| 2880 |
|
| 2881 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2882 | void XMLPrinter::PushUnknown( const char* value )
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2883 | {
|
Dmitry-Me | a092bc1 | 2014-12-23 17:57:05 +0300 | [diff] [blame] | 2884 | SealElementIfJustOpened();
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2885 | if ( _textDepth < 0 && !_firstElement && !_compactMode) {
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2886 | Putc( '\n' );
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2887 | PrintSpace( _depth );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2888 | }
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2889 | _firstElement = false;
|
Alexander Golubev | b2e08e4 | 2016-03-28 19:51:59 +0300 | [diff] [blame] | 2890 |
|
| 2891 | Write( "<!" );
|
| 2892 | Write( value );
|
Brad Anderson | 85aac02 | 2017-10-24 21:48:28 -0600 | [diff] [blame] | 2893 | Putc( '>' );
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2894 | }
|
| 2895 |
|
| 2896 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2897 | bool XMLPrinter::VisitEnter( const XMLDocument& doc )
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 2898 | {
|
Lee Thomason | 624d43f | 2012-10-12 10:58:48 -0700 | [diff] [blame] | 2899 | _processEntities = doc.ProcessEntities();
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2900 | if ( doc.HasBOM() ) {
|
| 2901 | PushHeader( true, false );
|
| 2902 | }
|
| 2903 | return true;
|
Lee Thomason (grinliz) | 68db57e | 2012-02-21 09:08:12 -0800 | [diff] [blame] | 2904 | }
|
| 2905 |
|
| 2906 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2907 | bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 2908 | {
|
Dmitry-Me | e76b851 | 2015-04-08 13:41:40 +0300 | [diff] [blame] | 2909 | const XMLElement* parentElem = 0;
|
| 2910 | if ( element.Parent() ) {
|
| 2911 | parentElem = element.Parent()->ToElement();
|
Ant Mitchell | 7e74477 | 2015-03-24 14:33:28 +0000 | [diff] [blame] | 2912 | }
|
Dmitry-Me | e76b851 | 2015-04-08 13:41:40 +0300 | [diff] [blame] | 2913 | const bool compactMode = parentElem ? CompactMode( *parentElem ) : _compactMode;
|
Uli Kusterer | 5d1d27e | 2014-02-20 11:50:22 +0100 | [diff] [blame] | 2914 | OpenElement( element.Name(), compactMode );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2915 | while ( attribute ) {
|
| 2916 | PushAttribute( attribute->Name(), attribute->Value() );
|
| 2917 | attribute = attribute->Next();
|
| 2918 | }
|
| 2919 | return true;
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 2920 | }
|
| 2921 |
|
| 2922 |
|
Uli Kusterer | ca412e8 | 2014-02-01 13:35:05 +0100 | [diff] [blame] | 2923 | bool XMLPrinter::VisitExit( const XMLElement& element )
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 2924 | {
|
Uli Kusterer | 5d1d27e | 2014-02-20 11:50:22 +0100 | [diff] [blame] | 2925 | CloseElement( CompactMode(element) );
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2926 | return true;
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 2927 | }
|
| 2928 |
|
| 2929 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2930 | bool XMLPrinter::Visit( const XMLText& text )
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 2931 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2932 | PushText( text.Value(), text.CData() );
|
| 2933 | return true;
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 2934 | }
|
| 2935 |
|
| 2936 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2937 | bool XMLPrinter::Visit( const XMLComment& comment )
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 2938 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2939 | PushComment( comment.Value() );
|
| 2940 | return true;
|
Lee Thomason | 751da52 | 2012-02-10 08:50:51 -0800 | [diff] [blame] | 2941 | }
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2942 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2943 | bool XMLPrinter::Visit( const XMLDeclaration& declaration )
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2944 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2945 | PushDeclaration( declaration.Value() );
|
| 2946 | return true;
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2947 | }
|
| 2948 |
|
| 2949 |
|
Lee Thomason (grinliz) | 2a1cd27 | 2012-02-24 17:37:53 -0800 | [diff] [blame] | 2950 | bool XMLPrinter::Visit( const XMLUnknown& unknown )
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2951 | {
|
Lee Thomason | a9cf3f9 | 2012-10-11 16:56:51 -0700 | [diff] [blame] | 2952 | PushUnknown( unknown.Value() );
|
| 2953 | return true;
|
Lee Thomason (grinliz) | bd0a8ac | 2012-02-20 20:14:33 -0800 | [diff] [blame] | 2954 | }
|
Kevin Wojniak | 04c22d2 | 2012-11-08 11:02:22 -0800 | [diff] [blame] | 2955 |
|
Lee Thomason | 685b895 | 2012-11-12 13:00:06 -0800 | [diff] [blame] | 2956 | } // namespace tinyxml2
|