U-Lama\Lee | e13c3e6 | 2011-12-28 14:36:55 -0800 | [diff] [blame] | 1 | #ifndef TINYXML2_INCLUDED
|
| 2 | #define TINYXML2_INCLUDED
|
| 3 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 4 | /*
|
| 5 | TODO
|
| 6 | - const and non-const versions of API
|
| 7 | - memory pool the class construction
|
| 8 | - attribute accessors
|
| 9 | - node navigation
|
| 10 | - handles
|
| 11 | - visit pattern - change streamer?
|
| 12 | - make constructors protected
|
| 13 | - hide copy constructor
|
| 14 | - hide = operator
|
| 15 | */
|
| 16 |
|
U-Lama\Lee | 4cee611 | 2011-12-31 14:58:18 -0800 | [diff] [blame] | 17 | #include <limits.h>
|
Lee Thomason | ce0763e | 2012-01-11 15:43:54 -0800 | [diff] [blame] | 18 | #include <ctype.h>
|
| 19 | #include <stdio.h>
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 20 | #include <memory.h>
|
U-Lama\Lee | 4cee611 | 2011-12-31 14:58:18 -0800 | [diff] [blame] | 21 |
|
| 22 | #if defined( _DEBUG ) || defined( DEBUG ) || defined (__DEBUG__)
|
| 23 | #ifndef DEBUG
|
| 24 | #define DEBUG
|
| 25 | #endif
|
| 26 | #endif
|
| 27 |
|
| 28 |
|
| 29 | #if defined(DEBUG)
|
| 30 | #if defined(_MSC_VER)
|
| 31 | #define TIXMLASSERT( x ) if ( !(x)) { _asm { int 3 } } //if ( !(x)) WinDebugBreak()
|
| 32 | #elif defined (ANDROID_NDK)
|
| 33 | #include <android/log.h>
|
| 34 | #define TIXMLASSERT( x ) if ( !(x)) { __android_log_assert( "assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__ ); }
|
| 35 | #else
|
| 36 | #include <assert.h>
|
| 37 | #define TIXMLASSERT assert
|
| 38 | #endif
|
| 39 | #else
|
| 40 | #define TIXMLASSERT( x ) {}
|
| 41 | #endif
|
| 42 |
|
U-Lama\Lee | e13c3e6 | 2011-12-28 14:36:55 -0800 | [diff] [blame] | 43 |
|
| 44 | namespace tinyxml2
|
| 45 | {
|
Lee Thomason | ce0763e | 2012-01-11 15:43:54 -0800 | [diff] [blame] | 46 | class XMLDocument;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 47 | class XMLElement;
|
| 48 | class XMLAttribute;
|
| 49 | class XMLComment;
|
| 50 | class XMLNode;
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 51 | class XMLText;
|
U-Lama\Lee | e13c3e6 | 2011-12-28 14:36:55 -0800 | [diff] [blame] | 52 |
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 53 | class XMLStreamer;
|
| 54 |
|
Lee Thomason | 39ede24 | 2012-01-20 11:27:56 -0800 | [diff] [blame] | 55 | class StrPair
|
| 56 | {
|
Lee Thomason | d34f52c | 2012-01-20 12:55:24 -0800 | [diff] [blame] | 57 | public:
|
Lee Thomason | 39ede24 | 2012-01-20 11:27:56 -0800 | [diff] [blame] | 58 | enum {
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 59 | NEEDS_ENTITY_PROCESSING = 0x01,
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 60 | NEEDS_NEWLINE_NORMALIZATION = 0x02,
|
| 61 |
|
| 62 | TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
|
| 63 | ATTRIBUTE_NAME = 0,
|
| 64 | ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
|
| 65 | COMMENT = NEEDS_NEWLINE_NORMALIZATION,
|
Lee Thomason | 39ede24 | 2012-01-20 11:27:56 -0800 | [diff] [blame] | 66 | };
|
| 67 |
|
| 68 | StrPair() : flags( 0 ), start( 0 ), end( 0 ) {}
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 69 | void Set( char* start, char* end, int flags ) {
|
Lee Thomason | 39ede24 | 2012-01-20 11:27:56 -0800 | [diff] [blame] | 70 | this->start = start; this->end = end; this->flags = flags | NEEDS_FLUSH;
|
| 71 | }
|
| 72 | const char* GetStr();
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 73 | bool Empty() const { return start == end; }
|
Lee Thomason | 39ede24 | 2012-01-20 11:27:56 -0800 | [diff] [blame] | 74 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 75 | void SetInternedStr( const char* str ) { this->start = (char*) str; this->end = 0; this->flags = 0; }
|
| 76 |
|
Lee Thomason | 39ede24 | 2012-01-20 11:27:56 -0800 | [diff] [blame] | 77 | private:
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 78 | enum {
|
| 79 | NEEDS_FLUSH = 0x100
|
| 80 | };
|
| 81 |
|
Lee Thomason | 39ede24 | 2012-01-20 11:27:56 -0800 | [diff] [blame] | 82 | // After parsing, if *end != 0, it can be set to zero.
|
| 83 | int flags;
|
Lee Thomason | e442230 | 2012-01-20 17:59:50 -0800 | [diff] [blame] | 84 | char* start;
|
Lee Thomason | 39ede24 | 2012-01-20 11:27:56 -0800 | [diff] [blame] | 85 | char* end;
|
| 86 | };
|
| 87 |
|
U-Lama\Lee | 560bd47 | 2011-12-28 19:42:49 -0800 | [diff] [blame] | 88 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 89 | template <class T, int INIT>
|
| 90 | class DynArray
|
| 91 | {
|
| 92 | public:
|
| 93 | DynArray< T, INIT >()
|
| 94 | {
|
| 95 | mem = pool;
|
| 96 | allocated = INIT;
|
| 97 | size = 0;
|
| 98 | }
|
| 99 | ~DynArray()
|
| 100 | {
|
| 101 | if ( mem != pool ) {
|
| 102 | delete mem;
|
| 103 | }
|
| 104 | }
|
| 105 | void Push( T t )
|
| 106 | {
|
| 107 | EnsureCapacity( size+1 );
|
| 108 | mem[size++] = t;
|
| 109 | }
|
| 110 |
|
| 111 | T* PushArr( int count )
|
| 112 | {
|
| 113 | EnsureCapacity( size+count );
|
| 114 | T* ret = &mem[size];
|
| 115 | size += count;
|
| 116 | return ret;
|
| 117 | }
|
| 118 | T Pop() {
|
| 119 | return mem[--size];
|
| 120 | }
|
| 121 | void PopArr( int count )
|
| 122 | {
|
| 123 | TIXMLASSERT( size >= count );
|
| 124 | size -= count;
|
| 125 | }
|
| 126 |
|
| 127 | bool Empty() const { return size == 0; }
|
| 128 | T& operator[](int i) { TIXMLASSERT( i>= 0 && i < size ); return mem[i]; }
|
| 129 | const T& operator[](int i) const { TIXMLASSERT( i>= 0 && i < size ); return mem[i]; }
|
| 130 | int Size() const { return size; }
|
| 131 | const T* Mem() const { return mem; }
|
| 132 | T* Mem() { return mem; }
|
| 133 |
|
| 134 |
|
| 135 | private:
|
| 136 | void EnsureCapacity( int cap ) {
|
| 137 | if ( cap > allocated ) {
|
| 138 | int newAllocated = cap * 2;
|
| 139 | T* newMem = new T[newAllocated];
|
| 140 | memcpy( newMem, mem, sizeof(T)*size ); // warning: not using constructors, only works for PODs
|
| 141 | if ( mem != pool ) delete [] mem;
|
| 142 | mem = newMem;
|
| 143 | allocated = newAllocated;
|
| 144 | }
|
| 145 | }
|
| 146 |
|
| 147 | T* mem;
|
| 148 | T pool[INIT];
|
| 149 | int allocated; // objects allocated
|
| 150 | int size; // number objects in use
|
| 151 | };
|
| 152 |
|
| 153 |
|
| 154 | /*
|
| 155 | class StringStack
|
| 156 | {
|
| 157 | public:
|
| 158 | StringStack();
|
| 159 | virtual ~StringStack();
|
| 160 |
|
| 161 | void Push( const char* str );
|
| 162 | const char* Pop();
|
| 163 |
|
| 164 | int NumPositive() const { return nPositive; }
|
| 165 |
|
| 166 | private:
|
| 167 | DynArray< char, 50 > mem;
|
| 168 | int nPositive; // number of strings with len > 0
|
| 169 | };
|
| 170 | */
|
| 171 |
|
| 172 | /*
|
| 173 | class StringPool
|
| 174 | {
|
| 175 | public:
|
| 176 | enum { INIT_SIZE=20 };
|
| 177 |
|
| 178 | StringPool() : size( 0 ) {
|
| 179 | const char** mem = pool.PushArr( INIT_SIZE );
|
| 180 | memset( (void*)mem, 0, sizeof(char)*INIT_SIZE );
|
| 181 | }
|
| 182 | ~StringPool() {}
|
| 183 |
|
| 184 | const char* Intern( const char* str );
|
| 185 |
|
| 186 | private:
|
| 187 | // FNV hash
|
| 188 | int Hash( const char* s ) {
|
| 189 | #define FNV_32_PRIME ((int)0x01000193)
|
| 190 | int hval = 0;
|
| 191 | while (*s) {
|
| 192 | hval *= FNV_32_PRIME;
|
| 193 | hval ^= (int)*s++;
|
| 194 | }
|
| 195 | return hval;
|
| 196 | }
|
| 197 |
|
| 198 | int size;
|
| 199 | DynArray< const char*, INIT_SIZE > pool; // the hash table
|
| 200 | StringStack store; // memory for the interned strings
|
| 201 | };
|
| 202 | */
|
| 203 |
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 204 | class XMLBase
|
U-Lama\Lee | e13c3e6 | 2011-12-28 14:36:55 -0800 | [diff] [blame] | 205 | {
|
| 206 | public:
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 207 | XMLBase() {}
|
| 208 | virtual ~XMLBase() {}
|
U-Lama\Lee | 4cee611 | 2011-12-31 14:58:18 -0800 | [diff] [blame] | 209 |
|
| 210 | protected:
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 211 | static const char* SkipWhiteSpace( const char* p ) { while( isspace( *p ) ) { ++p; } return p; }
|
| 212 | static char* SkipWhiteSpace( char* p ) { while( isspace( *p ) ) { ++p; } return p; }
|
U-Lama\Lee | 4cee611 | 2011-12-31 14:58:18 -0800 | [diff] [blame] | 213 |
|
| 214 | inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX ) {
|
| 215 | int n = 0;
|
Lee Thomason | d34f52c | 2012-01-20 12:55:24 -0800 | [diff] [blame] | 216 | if ( p == q ) {
|
| 217 | return true;
|
| 218 | }
|
U-Lama\Lee | 4cee611 | 2011-12-31 14:58:18 -0800 | [diff] [blame] | 219 | while( *p && *q && *p == *q && n<nChar ) {
|
| 220 | ++p; ++q; ++n;
|
| 221 | }
|
| 222 | if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {
|
| 223 | return true;
|
| 224 | }
|
| 225 | return false;
|
| 226 | }
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 227 | inline static int IsUTF8Continuation( unsigned char p ) { return p & 0x80; }
|
| 228 | inline static int IsAlphaNum( unsigned char anyByte ) { return ( anyByte <= 127 ) ? isalnum( anyByte ) : 1; }
|
| 229 | inline static int IsAlpha( unsigned char anyByte ) { return ( anyByte <= 127 ) ? isalpha( anyByte ) : 1; }
|
U-Lama\Lee | 4cee611 | 2011-12-31 14:58:18 -0800 | [diff] [blame] | 230 |
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 231 | char* ParseText( char* in, StrPair* pair, const char* endTag, int strFlags );
|
Lee Thomason | 39ede24 | 2012-01-20 11:27:56 -0800 | [diff] [blame] | 232 | char* ParseName( char* in, StrPair* pair );
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 233 | char* Identify( XMLDocument* document, char* p, XMLNode** node );
|
| 234 | };
|
| 235 |
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 236 |
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 237 | class XMLNode : public XMLBase
|
| 238 | {
|
| 239 | friend class XMLDocument;
|
| 240 | friend class XMLElement;
|
| 241 | public:
|
| 242 | virtual ~XMLNode();
|
| 243 |
|
| 244 | XMLNode* InsertEndChild( XMLNode* addThis );
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 245 | virtual void Print( XMLStreamer* streamer );
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 246 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 247 | const char* Value() const { return value.GetStr(); }
|
| 248 | void SetValue( const char* val ) { value.SetInternedStr( val ); }
|
| 249 |
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 250 | virtual XMLElement* ToElement() { return 0; }
|
| 251 | virtual XMLText* ToText() { return 0; }
|
| 252 | virtual XMLComment* ToComment() { return 0; }
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 253 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 254 | XMLNode* FirstChild() { return firstChild; }
|
| 255 | XMLElement* FirstChildElement( const char* value=0 );
|
| 256 |
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 257 | // fixme: guarentee null terminator to avoid internal checks
|
| 258 | virtual char* ParseDeep( char* );
|
| 259 |
|
| 260 | void SetTextParent() { isTextParent = true; }
|
| 261 | bool IsTextParent() const { return isTextParent; }
|
| 262 | virtual bool IsClosingElement() const { return false; }
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 263 |
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 264 | protected:
|
| 265 | XMLNode( XMLDocument* );
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 266 | void ClearChildren();
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 267 |
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 268 | XMLDocument* document;
|
| 269 | XMLNode* parent;
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 270 | bool isTextParent;
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 271 | mutable StrPair value;
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 272 |
|
| 273 | XMLNode* firstChild;
|
| 274 | XMLNode* lastChild;
|
| 275 |
|
| 276 | XMLNode* prev;
|
| 277 | XMLNode* next;
|
| 278 |
|
U-Lama\Lee | 4cee611 | 2011-12-31 14:58:18 -0800 | [diff] [blame] | 279 | private:
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 280 | void Unlink( XMLNode* child );
|
U-Lama\Lee | 4cee611 | 2011-12-31 14:58:18 -0800 | [diff] [blame] | 281 | };
|
| 282 |
|
| 283 |
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 284 | class XMLText : public XMLNode
|
| 285 | {
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 286 | friend class XMLBase;
|
| 287 | friend class XMLDocument;
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 288 | public:
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 289 | virtual ~XMLText() {}
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 290 | virtual void Print( XMLStreamer* streamer );
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 291 | const char* Value() { return value.GetStr(); }
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 292 | void SetValue( const char* );
|
| 293 |
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 294 | virtual XMLText* ToText() { return this; }
|
| 295 |
|
| 296 | char* ParseDeep( char* );
|
| 297 |
|
| 298 | protected:
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 299 | XMLText( XMLDocument* doc ) : XMLNode( doc ) {}
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 300 |
|
| 301 | private:
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 302 | };
|
| 303 |
|
| 304 |
|
U-Lama\Lee | 4cee611 | 2011-12-31 14:58:18 -0800 | [diff] [blame] | 305 | class XMLComment : public XMLNode
|
| 306 | {
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 307 | friend class XMLBase;
|
| 308 | friend class XMLDocument;
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 309 | public:
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 310 | virtual ~XMLComment();
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 311 | virtual void Print( XMLStreamer* );
|
Lee Thomason | 5492a1c | 2012-01-23 15:32:10 -0800 | [diff] [blame] | 312 | virtual XMLComment* ToComment() { return this; }
|
Lee Thomason | ce0763e | 2012-01-11 15:43:54 -0800 | [diff] [blame] | 313 |
|
Lee Thomason | d34f52c | 2012-01-20 12:55:24 -0800 | [diff] [blame] | 314 | const char* Value() { return value.GetStr(); }
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 315 |
|
Lee Thomason | ce0763e | 2012-01-11 15:43:54 -0800 | [diff] [blame] | 316 | char* ParseDeep( char* );
|
| 317 |
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 318 | protected:
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 319 | XMLComment( XMLDocument* doc );
|
| 320 |
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 321 |
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 322 | private:
|
U-Lama\Lee | 4cee611 | 2011-12-31 14:58:18 -0800 | [diff] [blame] | 323 | };
|
U-Lama\Lee | e13c3e6 | 2011-12-28 14:36:55 -0800 | [diff] [blame] | 324 |
|
| 325 |
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 326 | class XMLAttribute : public XMLBase
|
| 327 | {
|
| 328 | friend class XMLElement;
|
| 329 | public:
|
Lee Thomason | d34f52c | 2012-01-20 12:55:24 -0800 | [diff] [blame] | 330 | XMLAttribute( XMLElement* element ) : next( 0 ) {}
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 331 | virtual ~XMLAttribute() {}
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 332 | virtual void Print( XMLStreamer* streamer );
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 333 |
|
| 334 | private:
|
| 335 | char* ParseDeep( char* p );
|
| 336 |
|
Lee Thomason | 22aead1 | 2012-01-23 13:29:35 -0800 | [diff] [blame] | 337 | StrPair name;
|
Lee Thomason | d34f52c | 2012-01-20 12:55:24 -0800 | [diff] [blame] | 338 | StrPair value;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 339 | XMLAttribute* next;
|
| 340 | };
|
| 341 |
|
| 342 |
|
| 343 | class XMLElement : public XMLNode
|
| 344 | {
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 345 | friend class XMLBase;
|
| 346 | friend class XMLDocument;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 347 | public:
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 348 | virtual ~XMLElement();
|
| 349 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 350 | const char* Name() const { return Value(); }
|
| 351 | void SetName( const char* str ) { SetValue( str ); }
|
| 352 |
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 353 | virtual void Print( XMLStreamer* );
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 354 |
|
| 355 | virtual XMLElement* ToElement() { return this; }
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 356 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 357 | // internal:
|
| 358 | virtual bool IsClosingElement() const { return closing; }
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 359 | char* ParseDeep( char* p );
|
| 360 |
|
| 361 | protected:
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 362 | XMLElement( XMLDocument* doc );
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 363 |
|
| 364 | private:
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 365 | char* ParseAttributes( char* p, bool *closedElement );
|
| 366 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 367 | mutable StrPair name;
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 368 | bool closing;
|
| 369 | XMLAttribute* rootAttribute;
|
| 370 | XMLAttribute* lastAttribute;
|
| 371 | };
|
| 372 |
|
| 373 |
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 374 | class XMLDocument : public XMLNode
|
U-Lama\Lee | e13c3e6 | 2011-12-28 14:36:55 -0800 | [diff] [blame] | 375 | {
|
| 376 | public:
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 377 | XMLDocument();
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 378 | ~XMLDocument();
|
U-Lama\Lee | e13c3e6 | 2011-12-28 14:36:55 -0800 | [diff] [blame] | 379 |
|
Lee Thomason | 7c913cd | 2012-01-26 18:32:34 -0800 | [diff] [blame] | 380 | int Parse( const char* );
|
| 381 | int Load( const char* );
|
| 382 | int Load( FILE* );
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 383 |
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 384 | void Print( XMLStreamer* streamer=0 );
|
U-Lama\Lee | e13c3e6 | 2011-12-28 14:36:55 -0800 | [diff] [blame] | 385 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 386 | XMLElement* NewElement( const char* name );
|
| 387 |
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 388 | enum {
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 389 | NO_ERROR = 0,
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 390 | ERROR_ELEMENT_MISMATCH,
|
| 391 | ERROR_PARSING_ELEMENT,
|
| 392 | ERROR_PARSING_ATTRIBUTE
|
| 393 | };
|
Lee Thomason | 67d6131 | 2012-01-24 16:01:51 -0800 | [diff] [blame] | 394 | void SetError( int error, const char* str1, const char* str2 );
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 395 |
|
Lee Thomason | 7c913cd | 2012-01-26 18:32:34 -0800 | [diff] [blame] | 396 | bool Error() const { return errorID != NO_ERROR; }
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 397 | int GetErrorID() const { return errorID; }
|
| 398 | const char* GetErrorStr1() const { return errorStr1; }
|
| 399 | const char* GetErrorStr2() const { return errorStr2; }
|
Lee Thomason | 8a5dfee | 2012-01-18 17:43:40 -0800 | [diff] [blame] | 400 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 401 | // const char* Intern( const char* );
|
| 402 |
|
Lee Thomason | 3f57d27 | 2012-01-11 15:30:03 -0800 | [diff] [blame] | 403 | private:
|
| 404 | XMLDocument( const XMLDocument& ); // intentionally not implemented
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 405 | void InitDocument();
|
| 406 |
|
Lee Thomason | 7c913cd | 2012-01-26 18:32:34 -0800 | [diff] [blame] | 407 | int errorID;
|
Lee Thomason | 18d68bd | 2012-01-26 18:17:26 -0800 | [diff] [blame] | 408 | const char* errorStr1;
|
| 409 | const char* errorStr2;
|
| 410 | char* charBuffer;
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 411 | //StringStack stringPool;
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 412 | };
|
| 413 |
|
Lee Thomason | 7c913cd | 2012-01-26 18:32:34 -0800 | [diff] [blame] | 414 |
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 415 | class XMLStreamer
|
| 416 | {
|
| 417 | public:
|
| 418 | XMLStreamer( FILE* file );
|
| 419 | ~XMLStreamer() {}
|
| 420 |
|
| 421 | void OpenElement( const char* name, bool textParent );
|
| 422 | void PushAttribute( const char* name, const char* value );
|
| 423 | void CloseElement();
|
| 424 |
|
| 425 | void PushText( const char* text );
|
| 426 | void PushComment( const char* comment );
|
| 427 |
|
| 428 | private:
|
| 429 | void SealElement();
|
| 430 | void PrintSpace( int depth );
|
Lee Thomason | 857b868 | 2012-01-25 17:50:25 -0800 | [diff] [blame] | 431 | void PrintString( const char* ); // prints out, after detecting entities.
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 432 | bool TextOnStack() const {
|
| 433 | for( int i=0; i<text.Size(); ++i ) {
|
| 434 | if ( text[i] == 'T' )
|
| 435 | return true;
|
| 436 | }
|
| 437 | return false;
|
| 438 | }
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 439 |
|
| 440 | FILE* fp;
|
| 441 | int depth;
|
| 442 | bool elementJustOpened;
|
Lee Thomason | 857b868 | 2012-01-25 17:50:25 -0800 | [diff] [blame] | 443 | enum {
|
Lee Thomason | 951d883 | 2012-01-26 08:47:06 -0800 | [diff] [blame] | 444 | ENTITY_RANGE = 64
|
Lee Thomason | 857b868 | 2012-01-25 17:50:25 -0800 | [diff] [blame] | 445 | };
|
| 446 | bool entityFlag[ENTITY_RANGE];
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 447 |
|
Lee Thomason | 2c85a71 | 2012-01-31 08:24:24 -0800 | [diff] [blame^] | 448 | DynArray< const char*, 10 > stack;
|
| 449 | DynArray< char, 10 > text;
|
Lee Thomason | 5cae897 | 2012-01-24 18:03:07 -0800 | [diff] [blame] | 450 | };
|
| 451 |
|
| 452 |
|
U-Lama\Lee | e13c3e6 | 2011-12-28 14:36:55 -0800 | [diff] [blame] | 453 | }; // tinyxml2
|
| 454 |
|
U-Lama\Lee | 560bd47 | 2011-12-28 19:42:49 -0800 | [diff] [blame] | 455 |
|
| 456 |
|
U-Lama\Lee | e13c3e6 | 2011-12-28 14:36:55 -0800 | [diff] [blame] | 457 | #endif // TINYXML2_INCLUDED |