Download NHK English news podcast automatically. This application requires mpod mother board. See also http://mbed.org/users/geodenx/notebook/mpod/
Dependencies: BlinkLed HTTPClient EthernetInterface FatFileSystemCpp MSCFileSystem mbed-rtos mbed
Download NHK English news podcast automatically. This application requires mpod mother board. See also http://mbed.org/users/geodenx/notebook/mpod/
TinyXml2/tinyxml2.cpp@4:ab3092d15121, 2012-09-01 (annotated)
- Committer:
- togayan
- Date:
- Sat Sep 01 04:12:37 2012 +0000
- Revision:
- 4:ab3092d15121
- Parent:
- 0:1855a008f28e
HTTPFile was changed to follow the latest HTTPClient library.; BlinkLed was isolated as a library.; Change LED port from LED1,2 to LED3,4 for the specification of pwmout.
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
togayan | 0:1855a008f28e | 1 | /* |
togayan | 0:1855a008f28e | 2 | Original code by Lee Thomason (www.grinninglizard.com) |
togayan | 0:1855a008f28e | 3 | |
togayan | 0:1855a008f28e | 4 | This software is provided 'as-is', without any express or implied |
togayan | 0:1855a008f28e | 5 | warranty. In no event will the authors be held liable for any |
togayan | 0:1855a008f28e | 6 | damages arising from the use of this software. |
togayan | 0:1855a008f28e | 7 | |
togayan | 0:1855a008f28e | 8 | Permission is granted to anyone to use this software for any |
togayan | 0:1855a008f28e | 9 | purpose, including commercial applications, and to alter it and |
togayan | 0:1855a008f28e | 10 | redistribute it freely, subject to the following restrictions: |
togayan | 0:1855a008f28e | 11 | |
togayan | 0:1855a008f28e | 12 | 1. The origin of this software must not be misrepresented; you must |
togayan | 0:1855a008f28e | 13 | not claim that you wrote the original software. If you use this |
togayan | 0:1855a008f28e | 14 | software in a product, an acknowledgment in the product documentation |
togayan | 0:1855a008f28e | 15 | would be appreciated but is not required. |
togayan | 0:1855a008f28e | 16 | |
togayan | 0:1855a008f28e | 17 | 2. Altered source versions must be plainly marked as such, and |
togayan | 0:1855a008f28e | 18 | must not be misrepresented as being the original software. |
togayan | 0:1855a008f28e | 19 | |
togayan | 0:1855a008f28e | 20 | 3. This notice may not be removed or altered from any source |
togayan | 0:1855a008f28e | 21 | distribution. |
togayan | 0:1855a008f28e | 22 | */ |
togayan | 0:1855a008f28e | 23 | |
togayan | 0:1855a008f28e | 24 | #include "tinyxml2.h" |
togayan | 0:1855a008f28e | 25 | |
togayan | 0:1855a008f28e | 26 | #include <cstdio> |
togayan | 0:1855a008f28e | 27 | #include <cstdlib> |
togayan | 0:1855a008f28e | 28 | #include <new> |
togayan | 0:1855a008f28e | 29 | #include <cstddef> |
togayan | 0:1855a008f28e | 30 | |
togayan | 0:1855a008f28e | 31 | using namespace tinyxml2; |
togayan | 0:1855a008f28e | 32 | using namespace std; |
togayan | 0:1855a008f28e | 33 | |
togayan | 0:1855a008f28e | 34 | static const char LINE_FEED = (char)0x0a; // all line endings are normalized to LF |
togayan | 0:1855a008f28e | 35 | static const char LF = LINE_FEED; |
togayan | 0:1855a008f28e | 36 | static const char CARRIAGE_RETURN = (char)0x0d; // CR gets filtered out |
togayan | 0:1855a008f28e | 37 | static const char CR = CARRIAGE_RETURN; |
togayan | 0:1855a008f28e | 38 | static const char SINGLE_QUOTE = '\''; |
togayan | 0:1855a008f28e | 39 | static const char DOUBLE_QUOTE = '\"'; |
togayan | 0:1855a008f28e | 40 | |
togayan | 0:1855a008f28e | 41 | // Bunch of unicode info at: |
togayan | 0:1855a008f28e | 42 | // http://www.unicode.org/faq/utf_bom.html |
togayan | 0:1855a008f28e | 43 | // ef bb bf (Microsoft "lead bytes") - designates UTF-8 |
togayan | 0:1855a008f28e | 44 | |
togayan | 0:1855a008f28e | 45 | static const unsigned char TIXML_UTF_LEAD_0 = 0xefU; |
togayan | 0:1855a008f28e | 46 | static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; |
togayan | 0:1855a008f28e | 47 | static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; |
togayan | 0:1855a008f28e | 48 | |
togayan | 0:1855a008f28e | 49 | |
togayan | 0:1855a008f28e | 50 | #define DELETE_NODE( node ) { \ |
togayan | 0:1855a008f28e | 51 | if ( node ) { \ |
togayan | 0:1855a008f28e | 52 | MemPool* pool = node->memPool; \ |
togayan | 0:1855a008f28e | 53 | node->~XMLNode(); \ |
togayan | 0:1855a008f28e | 54 | pool->Free( node ); \ |
togayan | 0:1855a008f28e | 55 | } \ |
togayan | 0:1855a008f28e | 56 | } |
togayan | 0:1855a008f28e | 57 | #define DELETE_ATTRIBUTE( attrib ) { \ |
togayan | 0:1855a008f28e | 58 | if ( attrib ) { \ |
togayan | 0:1855a008f28e | 59 | MemPool* pool = attrib->memPool; \ |
togayan | 0:1855a008f28e | 60 | attrib->~XMLAttribute(); \ |
togayan | 0:1855a008f28e | 61 | pool->Free( attrib ); \ |
togayan | 0:1855a008f28e | 62 | } \ |
togayan | 0:1855a008f28e | 63 | } |
togayan | 0:1855a008f28e | 64 | |
togayan | 0:1855a008f28e | 65 | struct Entity { |
togayan | 0:1855a008f28e | 66 | const char* pattern; |
togayan | 0:1855a008f28e | 67 | int length; |
togayan | 0:1855a008f28e | 68 | char value; |
togayan | 0:1855a008f28e | 69 | }; |
togayan | 0:1855a008f28e | 70 | |
togayan | 0:1855a008f28e | 71 | static const int NUM_ENTITIES = 5; |
togayan | 0:1855a008f28e | 72 | static const Entity entities[NUM_ENTITIES] = |
togayan | 0:1855a008f28e | 73 | { |
togayan | 0:1855a008f28e | 74 | { "quot", 4, DOUBLE_QUOTE }, |
togayan | 0:1855a008f28e | 75 | { "amp", 3, '&' }, |
togayan | 0:1855a008f28e | 76 | { "apos", 4, SINGLE_QUOTE }, |
togayan | 0:1855a008f28e | 77 | { "lt", 2, '<' }, |
togayan | 0:1855a008f28e | 78 | { "gt", 2, '>' } |
togayan | 0:1855a008f28e | 79 | }; |
togayan | 0:1855a008f28e | 80 | |
togayan | 0:1855a008f28e | 81 | |
togayan | 0:1855a008f28e | 82 | StrPair::~StrPair() |
togayan | 0:1855a008f28e | 83 | { |
togayan | 0:1855a008f28e | 84 | Reset(); |
togayan | 0:1855a008f28e | 85 | } |
togayan | 0:1855a008f28e | 86 | |
togayan | 0:1855a008f28e | 87 | |
togayan | 0:1855a008f28e | 88 | void StrPair::Reset() |
togayan | 0:1855a008f28e | 89 | { |
togayan | 0:1855a008f28e | 90 | if ( flags & NEEDS_DELETE ) { |
togayan | 0:1855a008f28e | 91 | delete [] start; |
togayan | 0:1855a008f28e | 92 | } |
togayan | 0:1855a008f28e | 93 | flags = 0; |
togayan | 0:1855a008f28e | 94 | start = 0; |
togayan | 0:1855a008f28e | 95 | end = 0; |
togayan | 0:1855a008f28e | 96 | } |
togayan | 0:1855a008f28e | 97 | |
togayan | 0:1855a008f28e | 98 | |
togayan | 0:1855a008f28e | 99 | void StrPair::SetStr( const char* str, int flags ) |
togayan | 0:1855a008f28e | 100 | { |
togayan | 0:1855a008f28e | 101 | Reset(); |
togayan | 0:1855a008f28e | 102 | size_t len = strlen( str ); |
togayan | 0:1855a008f28e | 103 | start = new char[ len+1 ]; |
togayan | 0:1855a008f28e | 104 | memcpy( start, str, len+1 ); |
togayan | 0:1855a008f28e | 105 | end = start + len; |
togayan | 0:1855a008f28e | 106 | this->flags = flags | NEEDS_DELETE; |
togayan | 0:1855a008f28e | 107 | } |
togayan | 0:1855a008f28e | 108 | |
togayan | 0:1855a008f28e | 109 | |
togayan | 0:1855a008f28e | 110 | char* StrPair::ParseText( char* p, const char* endTag, int strFlags ) |
togayan | 0:1855a008f28e | 111 | { |
togayan | 0:1855a008f28e | 112 | TIXMLASSERT( endTag && *endTag ); |
togayan | 0:1855a008f28e | 113 | |
togayan | 0:1855a008f28e | 114 | char* start = p; // fixme: hides a member |
togayan | 0:1855a008f28e | 115 | char endChar = *endTag; |
togayan | 0:1855a008f28e | 116 | size_t length = strlen( endTag ); |
togayan | 0:1855a008f28e | 117 | |
togayan | 0:1855a008f28e | 118 | // Inner loop of text parsing. |
togayan | 0:1855a008f28e | 119 | while ( *p ) { |
togayan | 0:1855a008f28e | 120 | if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) { |
togayan | 0:1855a008f28e | 121 | Set( start, p, strFlags ); |
togayan | 0:1855a008f28e | 122 | return p + length; |
togayan | 0:1855a008f28e | 123 | } |
togayan | 0:1855a008f28e | 124 | ++p; |
togayan | 0:1855a008f28e | 125 | } |
togayan | 0:1855a008f28e | 126 | return 0; |
togayan | 0:1855a008f28e | 127 | } |
togayan | 0:1855a008f28e | 128 | |
togayan | 0:1855a008f28e | 129 | |
togayan | 0:1855a008f28e | 130 | char* StrPair::ParseName( char* p ) |
togayan | 0:1855a008f28e | 131 | { |
togayan | 0:1855a008f28e | 132 | char* start = p; |
togayan | 0:1855a008f28e | 133 | |
togayan | 0:1855a008f28e | 134 | if ( !start || !(*start) ) { |
togayan | 0:1855a008f28e | 135 | return 0; |
togayan | 0:1855a008f28e | 136 | } |
togayan | 0:1855a008f28e | 137 | |
togayan | 0:1855a008f28e | 138 | if ( !XMLUtil::IsAlpha( *p ) ) { |
togayan | 0:1855a008f28e | 139 | return 0; |
togayan | 0:1855a008f28e | 140 | } |
togayan | 0:1855a008f28e | 141 | |
togayan | 0:1855a008f28e | 142 | while( *p && ( |
togayan | 0:1855a008f28e | 143 | XMLUtil::IsAlphaNum( (unsigned char) *p ) |
togayan | 0:1855a008f28e | 144 | || *p == '_' |
togayan | 0:1855a008f28e | 145 | || *p == '-' |
togayan | 0:1855a008f28e | 146 | || *p == '.' |
togayan | 0:1855a008f28e | 147 | || *p == ':' )) |
togayan | 0:1855a008f28e | 148 | { |
togayan | 0:1855a008f28e | 149 | ++p; |
togayan | 0:1855a008f28e | 150 | } |
togayan | 0:1855a008f28e | 151 | |
togayan | 0:1855a008f28e | 152 | if ( p > start ) { |
togayan | 0:1855a008f28e | 153 | Set( start, p, 0 ); |
togayan | 0:1855a008f28e | 154 | return p; |
togayan | 0:1855a008f28e | 155 | } |
togayan | 0:1855a008f28e | 156 | return 0; |
togayan | 0:1855a008f28e | 157 | } |
togayan | 0:1855a008f28e | 158 | |
togayan | 0:1855a008f28e | 159 | |
togayan | 0:1855a008f28e | 160 | |
togayan | 0:1855a008f28e | 161 | const char* StrPair::GetStr() |
togayan | 0:1855a008f28e | 162 | { |
togayan | 0:1855a008f28e | 163 | if ( flags & NEEDS_FLUSH ) { |
togayan | 0:1855a008f28e | 164 | *end = 0; |
togayan | 0:1855a008f28e | 165 | flags ^= NEEDS_FLUSH; |
togayan | 0:1855a008f28e | 166 | |
togayan | 0:1855a008f28e | 167 | if ( flags ) { |
togayan | 0:1855a008f28e | 168 | char* p = start; // the read pointer |
togayan | 0:1855a008f28e | 169 | char* q = start; // the write pointer |
togayan | 0:1855a008f28e | 170 | |
togayan | 0:1855a008f28e | 171 | while( p < end ) { |
togayan | 0:1855a008f28e | 172 | if ( (flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) { |
togayan | 0:1855a008f28e | 173 | // CR-LF pair becomes LF |
togayan | 0:1855a008f28e | 174 | // CR alone becomes LF |
togayan | 0:1855a008f28e | 175 | // LF-CR becomes LF |
togayan | 0:1855a008f28e | 176 | if ( *(p+1) == LF ) { |
togayan | 0:1855a008f28e | 177 | p += 2; |
togayan | 0:1855a008f28e | 178 | } |
togayan | 0:1855a008f28e | 179 | else { |
togayan | 0:1855a008f28e | 180 | ++p; |
togayan | 0:1855a008f28e | 181 | } |
togayan | 0:1855a008f28e | 182 | *q++ = LF; |
togayan | 0:1855a008f28e | 183 | } |
togayan | 0:1855a008f28e | 184 | else if ( (flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) { |
togayan | 0:1855a008f28e | 185 | if ( *(p+1) == CR ) { |
togayan | 0:1855a008f28e | 186 | p += 2; |
togayan | 0:1855a008f28e | 187 | } |
togayan | 0:1855a008f28e | 188 | else { |
togayan | 0:1855a008f28e | 189 | ++p; |
togayan | 0:1855a008f28e | 190 | } |
togayan | 0:1855a008f28e | 191 | *q++ = LF; |
togayan | 0:1855a008f28e | 192 | } |
togayan | 0:1855a008f28e | 193 | else if ( (flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) { |
togayan | 0:1855a008f28e | 194 | // Entities handled by tinyXML2: |
togayan | 0:1855a008f28e | 195 | // - special entities in the entity table [in/out] |
togayan | 0:1855a008f28e | 196 | // - numeric character reference [in] |
togayan | 0:1855a008f28e | 197 | // 中 or 中 |
togayan | 0:1855a008f28e | 198 | |
togayan | 0:1855a008f28e | 199 | if ( *(p+1) == '#' ) { |
togayan | 0:1855a008f28e | 200 | char buf[10] = { 0 }; |
togayan | 0:1855a008f28e | 201 | int len; |
togayan | 0:1855a008f28e | 202 | p = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) ); |
togayan | 0:1855a008f28e | 203 | for( int i=0; i<len; ++i ) { |
togayan | 0:1855a008f28e | 204 | *q++ = buf[i]; |
togayan | 0:1855a008f28e | 205 | } |
togayan | 0:1855a008f28e | 206 | TIXMLASSERT( q <= p ); |
togayan | 0:1855a008f28e | 207 | } |
togayan | 0:1855a008f28e | 208 | else { |
togayan | 0:1855a008f28e | 209 | int i=0; |
togayan | 0:1855a008f28e | 210 | for(; i<NUM_ENTITIES; ++i ) { |
togayan | 0:1855a008f28e | 211 | if ( strncmp( p+1, entities[i].pattern, entities[i].length ) == 0 |
togayan | 0:1855a008f28e | 212 | && *(p+entities[i].length+1) == ';' ) |
togayan | 0:1855a008f28e | 213 | { |
togayan | 0:1855a008f28e | 214 | // Found an entity convert; |
togayan | 0:1855a008f28e | 215 | *q = entities[i].value; |
togayan | 0:1855a008f28e | 216 | ++q; |
togayan | 0:1855a008f28e | 217 | p += entities[i].length + 2; |
togayan | 0:1855a008f28e | 218 | break; |
togayan | 0:1855a008f28e | 219 | } |
togayan | 0:1855a008f28e | 220 | } |
togayan | 0:1855a008f28e | 221 | if ( i == NUM_ENTITIES ) { |
togayan | 0:1855a008f28e | 222 | // fixme: treat as error? |
togayan | 0:1855a008f28e | 223 | ++p; |
togayan | 0:1855a008f28e | 224 | ++q; |
togayan | 0:1855a008f28e | 225 | } |
togayan | 0:1855a008f28e | 226 | } |
togayan | 0:1855a008f28e | 227 | } |
togayan | 0:1855a008f28e | 228 | else { |
togayan | 0:1855a008f28e | 229 | *q = *p; |
togayan | 0:1855a008f28e | 230 | ++p; |
togayan | 0:1855a008f28e | 231 | ++q; |
togayan | 0:1855a008f28e | 232 | } |
togayan | 0:1855a008f28e | 233 | } |
togayan | 0:1855a008f28e | 234 | *q = 0; |
togayan | 0:1855a008f28e | 235 | } |
togayan | 0:1855a008f28e | 236 | flags = (flags & NEEDS_DELETE); |
togayan | 0:1855a008f28e | 237 | } |
togayan | 0:1855a008f28e | 238 | return start; |
togayan | 0:1855a008f28e | 239 | } |
togayan | 0:1855a008f28e | 240 | |
togayan | 0:1855a008f28e | 241 | |
togayan | 0:1855a008f28e | 242 | |
togayan | 0:1855a008f28e | 243 | |
togayan | 0:1855a008f28e | 244 | // --------- XMLUtil ----------- // |
togayan | 0:1855a008f28e | 245 | |
togayan | 0:1855a008f28e | 246 | const char* XMLUtil::ReadBOM( const char* p, bool* bom ) |
togayan | 0:1855a008f28e | 247 | { |
togayan | 0:1855a008f28e | 248 | *bom = false; |
togayan | 0:1855a008f28e | 249 | const unsigned char* pu = reinterpret_cast<const unsigned char*>(p); |
togayan | 0:1855a008f28e | 250 | // Check for BOM: |
togayan | 0:1855a008f28e | 251 | if ( *(pu+0) == TIXML_UTF_LEAD_0 |
togayan | 0:1855a008f28e | 252 | && *(pu+1) == TIXML_UTF_LEAD_1 |
togayan | 0:1855a008f28e | 253 | && *(pu+2) == TIXML_UTF_LEAD_2 ) |
togayan | 0:1855a008f28e | 254 | { |
togayan | 0:1855a008f28e | 255 | *bom = true; |
togayan | 0:1855a008f28e | 256 | p += 3; |
togayan | 0:1855a008f28e | 257 | } |
togayan | 0:1855a008f28e | 258 | return p; |
togayan | 0:1855a008f28e | 259 | } |
togayan | 0:1855a008f28e | 260 | |
togayan | 0:1855a008f28e | 261 | |
togayan | 0:1855a008f28e | 262 | void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length ) |
togayan | 0:1855a008f28e | 263 | { |
togayan | 0:1855a008f28e | 264 | const unsigned long BYTE_MASK = 0xBF; |
togayan | 0:1855a008f28e | 265 | const unsigned long BYTE_MARK = 0x80; |
togayan | 0:1855a008f28e | 266 | const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; |
togayan | 0:1855a008f28e | 267 | |
togayan | 0:1855a008f28e | 268 | if (input < 0x80) |
togayan | 0:1855a008f28e | 269 | *length = 1; |
togayan | 0:1855a008f28e | 270 | else if ( input < 0x800 ) |
togayan | 0:1855a008f28e | 271 | *length = 2; |
togayan | 0:1855a008f28e | 272 | else if ( input < 0x10000 ) |
togayan | 0:1855a008f28e | 273 | *length = 3; |
togayan | 0:1855a008f28e | 274 | else if ( input < 0x200000 ) |
togayan | 0:1855a008f28e | 275 | *length = 4; |
togayan | 0:1855a008f28e | 276 | else |
togayan | 0:1855a008f28e | 277 | { *length = 0; return; } // This code won't covert this correctly anyway. |
togayan | 0:1855a008f28e | 278 | |
togayan | 0:1855a008f28e | 279 | output += *length; |
togayan | 0:1855a008f28e | 280 | |
togayan | 0:1855a008f28e | 281 | // Scary scary fall throughs. |
togayan | 0:1855a008f28e | 282 | switch (*length) |
togayan | 0:1855a008f28e | 283 | { |
togayan | 0:1855a008f28e | 284 | case 4: |
togayan | 0:1855a008f28e | 285 | --output; |
togayan | 0:1855a008f28e | 286 | *output = (char)((input | BYTE_MARK) & BYTE_MASK); |
togayan | 0:1855a008f28e | 287 | input >>= 6; |
togayan | 0:1855a008f28e | 288 | case 3: |
togayan | 0:1855a008f28e | 289 | --output; |
togayan | 0:1855a008f28e | 290 | *output = (char)((input | BYTE_MARK) & BYTE_MASK); |
togayan | 0:1855a008f28e | 291 | input >>= 6; |
togayan | 0:1855a008f28e | 292 | case 2: |
togayan | 0:1855a008f28e | 293 | --output; |
togayan | 0:1855a008f28e | 294 | *output = (char)((input | BYTE_MARK) & BYTE_MASK); |
togayan | 0:1855a008f28e | 295 | input >>= 6; |
togayan | 0:1855a008f28e | 296 | case 1: |
togayan | 0:1855a008f28e | 297 | --output; |
togayan | 0:1855a008f28e | 298 | *output = (char)(input | FIRST_BYTE_MARK[*length]); |
togayan | 0:1855a008f28e | 299 | } |
togayan | 0:1855a008f28e | 300 | } |
togayan | 0:1855a008f28e | 301 | |
togayan | 0:1855a008f28e | 302 | |
togayan | 0:1855a008f28e | 303 | const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length ) |
togayan | 0:1855a008f28e | 304 | { |
togayan | 0:1855a008f28e | 305 | // Presume an entity, and pull it out. |
togayan | 0:1855a008f28e | 306 | *length = 0; |
togayan | 0:1855a008f28e | 307 | |
togayan | 0:1855a008f28e | 308 | if ( *(p+1) == '#' && *(p+2) ) |
togayan | 0:1855a008f28e | 309 | { |
togayan | 0:1855a008f28e | 310 | unsigned long ucs = 0; |
togayan | 0:1855a008f28e | 311 | ptrdiff_t delta = 0; |
togayan | 0:1855a008f28e | 312 | unsigned mult = 1; |
togayan | 0:1855a008f28e | 313 | |
togayan | 0:1855a008f28e | 314 | if ( *(p+2) == 'x' ) |
togayan | 0:1855a008f28e | 315 | { |
togayan | 0:1855a008f28e | 316 | // Hexadecimal. |
togayan | 0:1855a008f28e | 317 | if ( !*(p+3) ) return 0; |
togayan | 0:1855a008f28e | 318 | |
togayan | 0:1855a008f28e | 319 | const char* q = p+3; |
togayan | 0:1855a008f28e | 320 | q = strchr( q, ';' ); |
togayan | 0:1855a008f28e | 321 | |
togayan | 0:1855a008f28e | 322 | if ( !q || !*q ) return 0; |
togayan | 0:1855a008f28e | 323 | |
togayan | 0:1855a008f28e | 324 | delta = q-p; |
togayan | 0:1855a008f28e | 325 | --q; |
togayan | 0:1855a008f28e | 326 | |
togayan | 0:1855a008f28e | 327 | while ( *q != 'x' ) |
togayan | 0:1855a008f28e | 328 | { |
togayan | 0:1855a008f28e | 329 | if ( *q >= '0' && *q <= '9' ) |
togayan | 0:1855a008f28e | 330 | ucs += mult * (*q - '0'); |
togayan | 0:1855a008f28e | 331 | else if ( *q >= 'a' && *q <= 'f' ) |
togayan | 0:1855a008f28e | 332 | ucs += mult * (*q - 'a' + 10); |
togayan | 0:1855a008f28e | 333 | else if ( *q >= 'A' && *q <= 'F' ) |
togayan | 0:1855a008f28e | 334 | ucs += mult * (*q - 'A' + 10 ); |
togayan | 0:1855a008f28e | 335 | else |
togayan | 0:1855a008f28e | 336 | return 0; |
togayan | 0:1855a008f28e | 337 | mult *= 16; |
togayan | 0:1855a008f28e | 338 | --q; |
togayan | 0:1855a008f28e | 339 | } |
togayan | 0:1855a008f28e | 340 | } |
togayan | 0:1855a008f28e | 341 | else |
togayan | 0:1855a008f28e | 342 | { |
togayan | 0:1855a008f28e | 343 | // Decimal. |
togayan | 0:1855a008f28e | 344 | if ( !*(p+2) ) return 0; |
togayan | 0:1855a008f28e | 345 | |
togayan | 0:1855a008f28e | 346 | const char* q = p+2; |
togayan | 0:1855a008f28e | 347 | q = strchr( q, ';' ); |
togayan | 0:1855a008f28e | 348 | |
togayan | 0:1855a008f28e | 349 | if ( !q || !*q ) return 0; |
togayan | 0:1855a008f28e | 350 | |
togayan | 0:1855a008f28e | 351 | delta = q-p; |
togayan | 0:1855a008f28e | 352 | --q; |
togayan | 0:1855a008f28e | 353 | |
togayan | 0:1855a008f28e | 354 | while ( *q != '#' ) |
togayan | 0:1855a008f28e | 355 | { |
togayan | 0:1855a008f28e | 356 | if ( *q >= '0' && *q <= '9' ) |
togayan | 0:1855a008f28e | 357 | ucs += mult * (*q - '0'); |
togayan | 0:1855a008f28e | 358 | else |
togayan | 0:1855a008f28e | 359 | return 0; |
togayan | 0:1855a008f28e | 360 | mult *= 10; |
togayan | 0:1855a008f28e | 361 | --q; |
togayan | 0:1855a008f28e | 362 | } |
togayan | 0:1855a008f28e | 363 | } |
togayan | 0:1855a008f28e | 364 | // convert the UCS to UTF-8 |
togayan | 0:1855a008f28e | 365 | ConvertUTF32ToUTF8( ucs, value, length ); |
togayan | 0:1855a008f28e | 366 | return p + delta + 1; |
togayan | 0:1855a008f28e | 367 | } |
togayan | 0:1855a008f28e | 368 | return p+1; |
togayan | 0:1855a008f28e | 369 | } |
togayan | 0:1855a008f28e | 370 | |
togayan | 0:1855a008f28e | 371 | |
togayan | 0:1855a008f28e | 372 | void XMLUtil::ToStr( int v, char* buffer, int bufferSize ) |
togayan | 0:1855a008f28e | 373 | { |
togayan | 0:1855a008f28e | 374 | TIXML_SNPRINTF( buffer, bufferSize, "%d", v ); |
togayan | 0:1855a008f28e | 375 | } |
togayan | 0:1855a008f28e | 376 | |
togayan | 0:1855a008f28e | 377 | |
togayan | 0:1855a008f28e | 378 | void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize ) |
togayan | 0:1855a008f28e | 379 | { |
togayan | 0:1855a008f28e | 380 | TIXML_SNPRINTF( buffer, bufferSize, "%u", v ); |
togayan | 0:1855a008f28e | 381 | } |
togayan | 0:1855a008f28e | 382 | |
togayan | 0:1855a008f28e | 383 | |
togayan | 0:1855a008f28e | 384 | void XMLUtil::ToStr( bool v, char* buffer, int bufferSize ) |
togayan | 0:1855a008f28e | 385 | { |
togayan | 0:1855a008f28e | 386 | TIXML_SNPRINTF( buffer, bufferSize, "%d", v ? 1 : 0 ); |
togayan | 0:1855a008f28e | 387 | } |
togayan | 0:1855a008f28e | 388 | |
togayan | 0:1855a008f28e | 389 | |
togayan | 0:1855a008f28e | 390 | void XMLUtil::ToStr( float v, char* buffer, int bufferSize ) |
togayan | 0:1855a008f28e | 391 | { |
togayan | 0:1855a008f28e | 392 | TIXML_SNPRINTF( buffer, bufferSize, "%f", v ); |
togayan | 0:1855a008f28e | 393 | } |
togayan | 0:1855a008f28e | 394 | |
togayan | 0:1855a008f28e | 395 | |
togayan | 0:1855a008f28e | 396 | void XMLUtil::ToStr( double v, char* buffer, int bufferSize ) |
togayan | 0:1855a008f28e | 397 | { |
togayan | 0:1855a008f28e | 398 | TIXML_SNPRINTF( buffer, bufferSize, "%f", v ); |
togayan | 0:1855a008f28e | 399 | } |
togayan | 0:1855a008f28e | 400 | |
togayan | 0:1855a008f28e | 401 | |
togayan | 0:1855a008f28e | 402 | bool XMLUtil::ToInt( const char* str, int* value ) |
togayan | 0:1855a008f28e | 403 | { |
togayan | 0:1855a008f28e | 404 | if ( TIXML_SSCANF( str, "%d", value ) == 1 ) |
togayan | 0:1855a008f28e | 405 | return true; |
togayan | 0:1855a008f28e | 406 | return false; |
togayan | 0:1855a008f28e | 407 | } |
togayan | 0:1855a008f28e | 408 | |
togayan | 0:1855a008f28e | 409 | bool XMLUtil::ToUnsigned( const char* str, unsigned *value ) |
togayan | 0:1855a008f28e | 410 | { |
togayan | 0:1855a008f28e | 411 | if ( TIXML_SSCANF( str, "%u", value ) == 1 ) |
togayan | 0:1855a008f28e | 412 | return true; |
togayan | 0:1855a008f28e | 413 | return false; |
togayan | 0:1855a008f28e | 414 | } |
togayan | 0:1855a008f28e | 415 | |
togayan | 0:1855a008f28e | 416 | bool XMLUtil::ToBool( const char* str, bool* value ) |
togayan | 0:1855a008f28e | 417 | { |
togayan | 0:1855a008f28e | 418 | int ival = 0; |
togayan | 0:1855a008f28e | 419 | if ( ToInt( str, &ival )) { |
togayan | 0:1855a008f28e | 420 | *value = (ival==0) ? false : true; |
togayan | 0:1855a008f28e | 421 | return true; |
togayan | 0:1855a008f28e | 422 | } |
togayan | 0:1855a008f28e | 423 | if ( StringEqual( str, "true" ) ) { |
togayan | 0:1855a008f28e | 424 | *value = true; |
togayan | 0:1855a008f28e | 425 | return true; |
togayan | 0:1855a008f28e | 426 | } |
togayan | 0:1855a008f28e | 427 | else if ( StringEqual( str, "false" ) ) { |
togayan | 0:1855a008f28e | 428 | *value = false; |
togayan | 0:1855a008f28e | 429 | return true; |
togayan | 0:1855a008f28e | 430 | } |
togayan | 0:1855a008f28e | 431 | return false; |
togayan | 0:1855a008f28e | 432 | } |
togayan | 0:1855a008f28e | 433 | |
togayan | 0:1855a008f28e | 434 | |
togayan | 0:1855a008f28e | 435 | bool XMLUtil::ToFloat( const char* str, float* value ) |
togayan | 0:1855a008f28e | 436 | { |
togayan | 0:1855a008f28e | 437 | if ( TIXML_SSCANF( str, "%f", value ) == 1 ) { |
togayan | 0:1855a008f28e | 438 | return true; |
togayan | 0:1855a008f28e | 439 | } |
togayan | 0:1855a008f28e | 440 | return false; |
togayan | 0:1855a008f28e | 441 | } |
togayan | 0:1855a008f28e | 442 | |
togayan | 0:1855a008f28e | 443 | bool XMLUtil::ToDouble( const char* str, double* value ) |
togayan | 0:1855a008f28e | 444 | { |
togayan | 0:1855a008f28e | 445 | if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) { |
togayan | 0:1855a008f28e | 446 | return true; |
togayan | 0:1855a008f28e | 447 | } |
togayan | 0:1855a008f28e | 448 | return false; |
togayan | 0:1855a008f28e | 449 | } |
togayan | 0:1855a008f28e | 450 | |
togayan | 0:1855a008f28e | 451 | |
togayan | 0:1855a008f28e | 452 | char* XMLDocument::Identify( char* p, XMLNode** node ) |
togayan | 0:1855a008f28e | 453 | { |
togayan | 0:1855a008f28e | 454 | XMLNode* returnNode = 0; |
togayan | 0:1855a008f28e | 455 | char* start = p; |
togayan | 0:1855a008f28e | 456 | p = XMLUtil::SkipWhiteSpace( p ); |
togayan | 0:1855a008f28e | 457 | if( !p || !*p ) |
togayan | 0:1855a008f28e | 458 | { |
togayan | 0:1855a008f28e | 459 | return p; |
togayan | 0:1855a008f28e | 460 | } |
togayan | 0:1855a008f28e | 461 | |
togayan | 0:1855a008f28e | 462 | // What is this thing? |
togayan | 0:1855a008f28e | 463 | // - Elements start with a letter or underscore, but xml is reserved. |
togayan | 0:1855a008f28e | 464 | // - Comments: <!-- |
togayan | 0:1855a008f28e | 465 | // - Decleration: <? |
togayan | 0:1855a008f28e | 466 | // - Everthing else is unknown to tinyxml. |
togayan | 0:1855a008f28e | 467 | // |
togayan | 0:1855a008f28e | 468 | |
togayan | 0:1855a008f28e | 469 | static const char* xmlHeader = { "<?" }; |
togayan | 0:1855a008f28e | 470 | static const char* commentHeader = { "<!--" }; |
togayan | 0:1855a008f28e | 471 | static const char* dtdHeader = { "<!" }; |
togayan | 0:1855a008f28e | 472 | static const char* cdataHeader = { "<![CDATA[" }; |
togayan | 0:1855a008f28e | 473 | static const char* elementHeader = { "<" }; // and a header for everything else; check last. |
togayan | 0:1855a008f28e | 474 | |
togayan | 0:1855a008f28e | 475 | static const int xmlHeaderLen = 2; |
togayan | 0:1855a008f28e | 476 | static const int commentHeaderLen = 4; |
togayan | 0:1855a008f28e | 477 | static const int dtdHeaderLen = 2; |
togayan | 0:1855a008f28e | 478 | static const int cdataHeaderLen = 9; |
togayan | 0:1855a008f28e | 479 | static const int elementHeaderLen = 1; |
togayan | 0:1855a008f28e | 480 | |
togayan | 0:1855a008f28e | 481 | #if defined(_MSC_VER) |
togayan | 0:1855a008f28e | 482 | #pragma warning ( push ) |
togayan | 0:1855a008f28e | 483 | #pragma warning ( disable : 4127 ) |
togayan | 0:1855a008f28e | 484 | #endif |
togayan | 0:1855a008f28e | 485 | TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) ); // use same memory pool |
togayan | 0:1855a008f28e | 486 | TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) ); // use same memory pool |
togayan | 0:1855a008f28e | 487 | #if defined(_MSC_VER) |
togayan | 0:1855a008f28e | 488 | #pragma warning (pop) |
togayan | 0:1855a008f28e | 489 | #endif |
togayan | 0:1855a008f28e | 490 | if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) { |
togayan | 0:1855a008f28e | 491 | returnNode = new (commentPool.Alloc()) XMLDeclaration( this ); |
togayan | 0:1855a008f28e | 492 | returnNode->memPool = &commentPool; |
togayan | 0:1855a008f28e | 493 | p += xmlHeaderLen; |
togayan | 0:1855a008f28e | 494 | } |
togayan | 0:1855a008f28e | 495 | else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) { |
togayan | 0:1855a008f28e | 496 | returnNode = new (commentPool.Alloc()) XMLComment( this ); |
togayan | 0:1855a008f28e | 497 | returnNode->memPool = &commentPool; |
togayan | 0:1855a008f28e | 498 | p += commentHeaderLen; |
togayan | 0:1855a008f28e | 499 | } |
togayan | 0:1855a008f28e | 500 | else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) { |
togayan | 0:1855a008f28e | 501 | XMLText* text = new (textPool.Alloc()) XMLText( this ); |
togayan | 0:1855a008f28e | 502 | returnNode = text; |
togayan | 0:1855a008f28e | 503 | returnNode->memPool = &textPool; |
togayan | 0:1855a008f28e | 504 | p += cdataHeaderLen; |
togayan | 0:1855a008f28e | 505 | text->SetCData( true ); |
togayan | 0:1855a008f28e | 506 | } |
togayan | 0:1855a008f28e | 507 | else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) { |
togayan | 0:1855a008f28e | 508 | returnNode = new (commentPool.Alloc()) XMLUnknown( this ); |
togayan | 0:1855a008f28e | 509 | returnNode->memPool = &commentPool; |
togayan | 0:1855a008f28e | 510 | p += dtdHeaderLen; |
togayan | 0:1855a008f28e | 511 | } |
togayan | 0:1855a008f28e | 512 | else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) { |
togayan | 0:1855a008f28e | 513 | returnNode = new (elementPool.Alloc()) XMLElement( this ); |
togayan | 0:1855a008f28e | 514 | returnNode->memPool = &elementPool; |
togayan | 0:1855a008f28e | 515 | p += elementHeaderLen; |
togayan | 0:1855a008f28e | 516 | } |
togayan | 0:1855a008f28e | 517 | else { |
togayan | 0:1855a008f28e | 518 | returnNode = new (textPool.Alloc()) XMLText( this ); |
togayan | 0:1855a008f28e | 519 | returnNode->memPool = &textPool; |
togayan | 0:1855a008f28e | 520 | p = start; // Back it up, all the text counts. |
togayan | 0:1855a008f28e | 521 | } |
togayan | 0:1855a008f28e | 522 | |
togayan | 0:1855a008f28e | 523 | *node = returnNode; |
togayan | 0:1855a008f28e | 524 | return p; |
togayan | 0:1855a008f28e | 525 | } |
togayan | 0:1855a008f28e | 526 | |
togayan | 0:1855a008f28e | 527 | |
togayan | 0:1855a008f28e | 528 | bool XMLDocument::Accept( XMLVisitor* visitor ) const |
togayan | 0:1855a008f28e | 529 | { |
togayan | 0:1855a008f28e | 530 | if ( visitor->VisitEnter( *this ) ) |
togayan | 0:1855a008f28e | 531 | { |
togayan | 0:1855a008f28e | 532 | for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) |
togayan | 0:1855a008f28e | 533 | { |
togayan | 0:1855a008f28e | 534 | if ( !node->Accept( visitor ) ) |
togayan | 0:1855a008f28e | 535 | break; |
togayan | 0:1855a008f28e | 536 | } |
togayan | 0:1855a008f28e | 537 | } |
togayan | 0:1855a008f28e | 538 | return visitor->VisitExit( *this ); |
togayan | 0:1855a008f28e | 539 | } |
togayan | 0:1855a008f28e | 540 | |
togayan | 0:1855a008f28e | 541 | |
togayan | 0:1855a008f28e | 542 | // --------- XMLNode ----------- // |
togayan | 0:1855a008f28e | 543 | |
togayan | 0:1855a008f28e | 544 | XMLNode::XMLNode( XMLDocument* doc ) : |
togayan | 0:1855a008f28e | 545 | document( doc ), |
togayan | 0:1855a008f28e | 546 | parent( 0 ), |
togayan | 0:1855a008f28e | 547 | firstChild( 0 ), lastChild( 0 ), |
togayan | 0:1855a008f28e | 548 | prev( 0 ), next( 0 ) |
togayan | 0:1855a008f28e | 549 | { |
togayan | 0:1855a008f28e | 550 | } |
togayan | 0:1855a008f28e | 551 | |
togayan | 0:1855a008f28e | 552 | |
togayan | 0:1855a008f28e | 553 | XMLNode::~XMLNode() |
togayan | 0:1855a008f28e | 554 | { |
togayan | 0:1855a008f28e | 555 | DeleteChildren(); |
togayan | 0:1855a008f28e | 556 | if ( parent ) { |
togayan | 0:1855a008f28e | 557 | parent->Unlink( this ); |
togayan | 0:1855a008f28e | 558 | } |
togayan | 0:1855a008f28e | 559 | } |
togayan | 0:1855a008f28e | 560 | |
togayan | 0:1855a008f28e | 561 | |
togayan | 0:1855a008f28e | 562 | void XMLNode::SetValue( const char* str, bool staticMem ) |
togayan | 0:1855a008f28e | 563 | { |
togayan | 0:1855a008f28e | 564 | if ( staticMem ) |
togayan | 0:1855a008f28e | 565 | value.SetInternedStr( str ); |
togayan | 0:1855a008f28e | 566 | else |
togayan | 0:1855a008f28e | 567 | value.SetStr( str ); |
togayan | 0:1855a008f28e | 568 | } |
togayan | 0:1855a008f28e | 569 | |
togayan | 0:1855a008f28e | 570 | |
togayan | 0:1855a008f28e | 571 | void XMLNode::DeleteChildren() |
togayan | 0:1855a008f28e | 572 | { |
togayan | 0:1855a008f28e | 573 | while( firstChild ) { |
togayan | 0:1855a008f28e | 574 | XMLNode* node = firstChild; |
togayan | 0:1855a008f28e | 575 | Unlink( node ); |
togayan | 0:1855a008f28e | 576 | |
togayan | 0:1855a008f28e | 577 | DELETE_NODE( node ); |
togayan | 0:1855a008f28e | 578 | } |
togayan | 0:1855a008f28e | 579 | firstChild = lastChild = 0; |
togayan | 0:1855a008f28e | 580 | } |
togayan | 0:1855a008f28e | 581 | |
togayan | 0:1855a008f28e | 582 | |
togayan | 0:1855a008f28e | 583 | void XMLNode::Unlink( XMLNode* child ) |
togayan | 0:1855a008f28e | 584 | { |
togayan | 0:1855a008f28e | 585 | TIXMLASSERT( child->parent == this ); |
togayan | 0:1855a008f28e | 586 | if ( child == firstChild ) |
togayan | 0:1855a008f28e | 587 | firstChild = firstChild->next; |
togayan | 0:1855a008f28e | 588 | if ( child == lastChild ) |
togayan | 0:1855a008f28e | 589 | lastChild = lastChild->prev; |
togayan | 0:1855a008f28e | 590 | |
togayan | 0:1855a008f28e | 591 | if ( child->prev ) { |
togayan | 0:1855a008f28e | 592 | child->prev->next = child->next; |
togayan | 0:1855a008f28e | 593 | } |
togayan | 0:1855a008f28e | 594 | if ( child->next ) { |
togayan | 0:1855a008f28e | 595 | child->next->prev = child->prev; |
togayan | 0:1855a008f28e | 596 | } |
togayan | 0:1855a008f28e | 597 | child->parent = 0; |
togayan | 0:1855a008f28e | 598 | } |
togayan | 0:1855a008f28e | 599 | |
togayan | 0:1855a008f28e | 600 | |
togayan | 0:1855a008f28e | 601 | void XMLNode::DeleteChild( XMLNode* node ) |
togayan | 0:1855a008f28e | 602 | { |
togayan | 0:1855a008f28e | 603 | TIXMLASSERT( node->parent == this ); |
togayan | 0:1855a008f28e | 604 | DELETE_NODE( node ); |
togayan | 0:1855a008f28e | 605 | } |
togayan | 0:1855a008f28e | 606 | |
togayan | 0:1855a008f28e | 607 | |
togayan | 0:1855a008f28e | 608 | XMLNode* XMLNode::InsertEndChild( XMLNode* addThis ) |
togayan | 0:1855a008f28e | 609 | { |
togayan | 0:1855a008f28e | 610 | if ( lastChild ) { |
togayan | 0:1855a008f28e | 611 | TIXMLASSERT( firstChild ); |
togayan | 0:1855a008f28e | 612 | TIXMLASSERT( lastChild->next == 0 ); |
togayan | 0:1855a008f28e | 613 | lastChild->next = addThis; |
togayan | 0:1855a008f28e | 614 | addThis->prev = lastChild; |
togayan | 0:1855a008f28e | 615 | lastChild = addThis; |
togayan | 0:1855a008f28e | 616 | |
togayan | 0:1855a008f28e | 617 | addThis->next = 0; |
togayan | 0:1855a008f28e | 618 | } |
togayan | 0:1855a008f28e | 619 | else { |
togayan | 0:1855a008f28e | 620 | TIXMLASSERT( firstChild == 0 ); |
togayan | 0:1855a008f28e | 621 | firstChild = lastChild = addThis; |
togayan | 0:1855a008f28e | 622 | |
togayan | 0:1855a008f28e | 623 | addThis->prev = 0; |
togayan | 0:1855a008f28e | 624 | addThis->next = 0; |
togayan | 0:1855a008f28e | 625 | } |
togayan | 0:1855a008f28e | 626 | addThis->parent = this; |
togayan | 0:1855a008f28e | 627 | return addThis; |
togayan | 0:1855a008f28e | 628 | } |
togayan | 0:1855a008f28e | 629 | |
togayan | 0:1855a008f28e | 630 | |
togayan | 0:1855a008f28e | 631 | XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis ) |
togayan | 0:1855a008f28e | 632 | { |
togayan | 0:1855a008f28e | 633 | if ( firstChild ) { |
togayan | 0:1855a008f28e | 634 | TIXMLASSERT( lastChild ); |
togayan | 0:1855a008f28e | 635 | TIXMLASSERT( firstChild->prev == 0 ); |
togayan | 0:1855a008f28e | 636 | |
togayan | 0:1855a008f28e | 637 | firstChild->prev = addThis; |
togayan | 0:1855a008f28e | 638 | addThis->next = firstChild; |
togayan | 0:1855a008f28e | 639 | firstChild = addThis; |
togayan | 0:1855a008f28e | 640 | |
togayan | 0:1855a008f28e | 641 | addThis->prev = 0; |
togayan | 0:1855a008f28e | 642 | } |
togayan | 0:1855a008f28e | 643 | else { |
togayan | 0:1855a008f28e | 644 | TIXMLASSERT( lastChild == 0 ); |
togayan | 0:1855a008f28e | 645 | firstChild = lastChild = addThis; |
togayan | 0:1855a008f28e | 646 | |
togayan | 0:1855a008f28e | 647 | addThis->prev = 0; |
togayan | 0:1855a008f28e | 648 | addThis->next = 0; |
togayan | 0:1855a008f28e | 649 | } |
togayan | 0:1855a008f28e | 650 | addThis->parent = this; |
togayan | 0:1855a008f28e | 651 | return addThis; |
togayan | 0:1855a008f28e | 652 | } |
togayan | 0:1855a008f28e | 653 | |
togayan | 0:1855a008f28e | 654 | |
togayan | 0:1855a008f28e | 655 | XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis ) |
togayan | 0:1855a008f28e | 656 | { |
togayan | 0:1855a008f28e | 657 | TIXMLASSERT( afterThis->parent == this ); |
togayan | 0:1855a008f28e | 658 | if ( afterThis->parent != this ) |
togayan | 0:1855a008f28e | 659 | return 0; |
togayan | 0:1855a008f28e | 660 | |
togayan | 0:1855a008f28e | 661 | if ( afterThis->next == 0 ) { |
togayan | 0:1855a008f28e | 662 | // The last node or the only node. |
togayan | 0:1855a008f28e | 663 | return InsertEndChild( addThis ); |
togayan | 0:1855a008f28e | 664 | } |
togayan | 0:1855a008f28e | 665 | addThis->prev = afterThis; |
togayan | 0:1855a008f28e | 666 | addThis->next = afterThis->next; |
togayan | 0:1855a008f28e | 667 | afterThis->next->prev = addThis; |
togayan | 0:1855a008f28e | 668 | afterThis->next = addThis; |
togayan | 0:1855a008f28e | 669 | addThis->parent = this; |
togayan | 0:1855a008f28e | 670 | return addThis; |
togayan | 0:1855a008f28e | 671 | } |
togayan | 0:1855a008f28e | 672 | |
togayan | 0:1855a008f28e | 673 | |
togayan | 0:1855a008f28e | 674 | |
togayan | 0:1855a008f28e | 675 | |
togayan | 0:1855a008f28e | 676 | const XMLElement* XMLNode::FirstChildElement( const char* value ) const |
togayan | 0:1855a008f28e | 677 | { |
togayan | 0:1855a008f28e | 678 | for( XMLNode* node=firstChild; node; node=node->next ) { |
togayan | 0:1855a008f28e | 679 | XMLElement* element = node->ToElement(); |
togayan | 0:1855a008f28e | 680 | if ( element ) { |
togayan | 0:1855a008f28e | 681 | if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) { |
togayan | 0:1855a008f28e | 682 | return element; |
togayan | 0:1855a008f28e | 683 | } |
togayan | 0:1855a008f28e | 684 | } |
togayan | 0:1855a008f28e | 685 | } |
togayan | 0:1855a008f28e | 686 | return 0; |
togayan | 0:1855a008f28e | 687 | } |
togayan | 0:1855a008f28e | 688 | |
togayan | 0:1855a008f28e | 689 | |
togayan | 0:1855a008f28e | 690 | const XMLElement* XMLNode::LastChildElement( const char* value ) const |
togayan | 0:1855a008f28e | 691 | { |
togayan | 0:1855a008f28e | 692 | for( XMLNode* node=lastChild; node; node=node->prev ) { |
togayan | 0:1855a008f28e | 693 | XMLElement* element = node->ToElement(); |
togayan | 0:1855a008f28e | 694 | if ( element ) { |
togayan | 0:1855a008f28e | 695 | if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) { |
togayan | 0:1855a008f28e | 696 | return element; |
togayan | 0:1855a008f28e | 697 | } |
togayan | 0:1855a008f28e | 698 | } |
togayan | 0:1855a008f28e | 699 | } |
togayan | 0:1855a008f28e | 700 | return 0; |
togayan | 0:1855a008f28e | 701 | } |
togayan | 0:1855a008f28e | 702 | |
togayan | 0:1855a008f28e | 703 | |
togayan | 0:1855a008f28e | 704 | const XMLElement* XMLNode::NextSiblingElement( const char* value ) const |
togayan | 0:1855a008f28e | 705 | { |
togayan | 0:1855a008f28e | 706 | for( XMLNode* element=this->next; element; element = element->next ) { |
togayan | 0:1855a008f28e | 707 | if ( element->ToElement() |
togayan | 0:1855a008f28e | 708 | && (!value || XMLUtil::StringEqual( value, element->Value() ))) |
togayan | 0:1855a008f28e | 709 | { |
togayan | 0:1855a008f28e | 710 | return element->ToElement(); |
togayan | 0:1855a008f28e | 711 | } |
togayan | 0:1855a008f28e | 712 | } |
togayan | 0:1855a008f28e | 713 | return 0; |
togayan | 0:1855a008f28e | 714 | } |
togayan | 0:1855a008f28e | 715 | |
togayan | 0:1855a008f28e | 716 | |
togayan | 0:1855a008f28e | 717 | const XMLElement* XMLNode::PreviousSiblingElement( const char* value ) const |
togayan | 0:1855a008f28e | 718 | { |
togayan | 0:1855a008f28e | 719 | for( XMLNode* element=this->prev; element; element = element->prev ) { |
togayan | 0:1855a008f28e | 720 | if ( element->ToElement() |
togayan | 0:1855a008f28e | 721 | && (!value || XMLUtil::StringEqual( value, element->Value() ))) |
togayan | 0:1855a008f28e | 722 | { |
togayan | 0:1855a008f28e | 723 | return element->ToElement(); |
togayan | 0:1855a008f28e | 724 | } |
togayan | 0:1855a008f28e | 725 | } |
togayan | 0:1855a008f28e | 726 | return 0; |
togayan | 0:1855a008f28e | 727 | } |
togayan | 0:1855a008f28e | 728 | |
togayan | 0:1855a008f28e | 729 | |
togayan | 0:1855a008f28e | 730 | char* XMLNode::ParseDeep( char* p, StrPair* parentEnd ) |
togayan | 0:1855a008f28e | 731 | { |
togayan | 0:1855a008f28e | 732 | // This is a recursive method, but thinking about it "at the current level" |
togayan | 0:1855a008f28e | 733 | // it is a pretty simple flat list: |
togayan | 0:1855a008f28e | 734 | // <foo/> |
togayan | 0:1855a008f28e | 735 | // <!-- comment --> |
togayan | 0:1855a008f28e | 736 | // |
togayan | 0:1855a008f28e | 737 | // With a special case: |
togayan | 0:1855a008f28e | 738 | // <foo> |
togayan | 0:1855a008f28e | 739 | // </foo> |
togayan | 0:1855a008f28e | 740 | // <!-- comment --> |
togayan | 0:1855a008f28e | 741 | // |
togayan | 0:1855a008f28e | 742 | // Where the closing element (/foo) *must* be the next thing after the opening |
togayan | 0:1855a008f28e | 743 | // element, and the names must match. BUT the tricky bit is that the closing |
togayan | 0:1855a008f28e | 744 | // element will be read by the child. |
togayan | 0:1855a008f28e | 745 | // |
togayan | 0:1855a008f28e | 746 | // 'endTag' is the end tag for this node, it is returned by a call to a child. |
togayan | 0:1855a008f28e | 747 | // 'parentEnd' is the end tag for the parent, which is filled in and returned. |
togayan | 0:1855a008f28e | 748 | |
togayan | 0:1855a008f28e | 749 | while( p && *p ) { |
togayan | 0:1855a008f28e | 750 | XMLNode* node = 0; |
togayan | 0:1855a008f28e | 751 | |
togayan | 0:1855a008f28e | 752 | p = document->Identify( p, &node ); |
togayan | 0:1855a008f28e | 753 | if ( p == 0 || node == 0 ) { |
togayan | 0:1855a008f28e | 754 | break; |
togayan | 0:1855a008f28e | 755 | } |
togayan | 0:1855a008f28e | 756 | |
togayan | 0:1855a008f28e | 757 | StrPair endTag; |
togayan | 0:1855a008f28e | 758 | p = node->ParseDeep( p, &endTag ); |
togayan | 0:1855a008f28e | 759 | if ( !p ) { |
togayan | 0:1855a008f28e | 760 | DELETE_NODE( node ); |
togayan | 0:1855a008f28e | 761 | node = 0; |
togayan | 0:1855a008f28e | 762 | if ( !document->Error() ) { |
togayan | 0:1855a008f28e | 763 | document->SetError( XML_ERROR_PARSING, 0, 0 ); |
togayan | 0:1855a008f28e | 764 | } |
togayan | 0:1855a008f28e | 765 | break; |
togayan | 0:1855a008f28e | 766 | } |
togayan | 0:1855a008f28e | 767 | |
togayan | 0:1855a008f28e | 768 | // We read the end tag. Return it to the parent. |
togayan | 0:1855a008f28e | 769 | if ( node->ToElement() && node->ToElement()->ClosingType() == XMLElement::CLOSING ) { |
togayan | 0:1855a008f28e | 770 | if ( parentEnd ) { |
togayan | 0:1855a008f28e | 771 | *parentEnd = static_cast<XMLElement*>(node)->value; |
togayan | 0:1855a008f28e | 772 | } |
togayan | 0:1855a008f28e | 773 | DELETE_NODE( node ); |
togayan | 0:1855a008f28e | 774 | return p; |
togayan | 0:1855a008f28e | 775 | } |
togayan | 0:1855a008f28e | 776 | |
togayan | 0:1855a008f28e | 777 | // Handle an end tag returned to this level. |
togayan | 0:1855a008f28e | 778 | // And handle a bunch of annoying errors. |
togayan | 0:1855a008f28e | 779 | XMLElement* ele = node->ToElement(); |
togayan | 0:1855a008f28e | 780 | if ( ele ) { |
togayan | 0:1855a008f28e | 781 | if ( endTag.Empty() && ele->ClosingType() == XMLElement::OPEN ) { |
togayan | 0:1855a008f28e | 782 | document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 ); |
togayan | 0:1855a008f28e | 783 | p = 0; |
togayan | 0:1855a008f28e | 784 | } |
togayan | 0:1855a008f28e | 785 | else if ( !endTag.Empty() && ele->ClosingType() != XMLElement::OPEN ) { |
togayan | 0:1855a008f28e | 786 | document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 ); |
togayan | 0:1855a008f28e | 787 | p = 0; |
togayan | 0:1855a008f28e | 788 | } |
togayan | 0:1855a008f28e | 789 | else if ( !endTag.Empty() ) { |
togayan | 0:1855a008f28e | 790 | if ( !XMLUtil::StringEqual( endTag.GetStr(), node->Value() )) { |
togayan | 0:1855a008f28e | 791 | document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 ); |
togayan | 0:1855a008f28e | 792 | p = 0; |
togayan | 0:1855a008f28e | 793 | } |
togayan | 0:1855a008f28e | 794 | } |
togayan | 0:1855a008f28e | 795 | } |
togayan | 0:1855a008f28e | 796 | if ( p == 0 ) { |
togayan | 0:1855a008f28e | 797 | DELETE_NODE( node ); |
togayan | 0:1855a008f28e | 798 | node = 0; |
togayan | 0:1855a008f28e | 799 | } |
togayan | 0:1855a008f28e | 800 | if ( node ) { |
togayan | 0:1855a008f28e | 801 | this->InsertEndChild( node ); |
togayan | 0:1855a008f28e | 802 | } |
togayan | 0:1855a008f28e | 803 | } |
togayan | 0:1855a008f28e | 804 | return 0; |
togayan | 0:1855a008f28e | 805 | } |
togayan | 0:1855a008f28e | 806 | |
togayan | 0:1855a008f28e | 807 | // --------- XMLText ---------- // |
togayan | 0:1855a008f28e | 808 | char* XMLText::ParseDeep( char* p, StrPair* ) |
togayan | 0:1855a008f28e | 809 | { |
togayan | 0:1855a008f28e | 810 | const char* start = p; |
togayan | 0:1855a008f28e | 811 | if ( this->CData() ) { |
togayan | 0:1855a008f28e | 812 | p = value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION ); |
togayan | 0:1855a008f28e | 813 | if ( !p ) { |
togayan | 0:1855a008f28e | 814 | document->SetError( XML_ERROR_PARSING_CDATA, start, 0 ); |
togayan | 0:1855a008f28e | 815 | } |
togayan | 0:1855a008f28e | 816 | return p; |
togayan | 0:1855a008f28e | 817 | } |
togayan | 0:1855a008f28e | 818 | else { |
togayan | 0:1855a008f28e | 819 | p = value.ParseText( p, "<", document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES ); |
togayan | 0:1855a008f28e | 820 | if ( !p ) { |
togayan | 0:1855a008f28e | 821 | document->SetError( XML_ERROR_PARSING_TEXT, start, 0 ); |
togayan | 0:1855a008f28e | 822 | } |
togayan | 0:1855a008f28e | 823 | if ( p && *p ) { |
togayan | 0:1855a008f28e | 824 | return p-1; |
togayan | 0:1855a008f28e | 825 | } |
togayan | 0:1855a008f28e | 826 | } |
togayan | 0:1855a008f28e | 827 | return 0; |
togayan | 0:1855a008f28e | 828 | } |
togayan | 0:1855a008f28e | 829 | |
togayan | 0:1855a008f28e | 830 | |
togayan | 0:1855a008f28e | 831 | XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const |
togayan | 0:1855a008f28e | 832 | { |
togayan | 0:1855a008f28e | 833 | if ( !doc ) { |
togayan | 0:1855a008f28e | 834 | doc = document; |
togayan | 0:1855a008f28e | 835 | } |
togayan | 0:1855a008f28e | 836 | XMLText* text = doc->NewText( Value() ); // fixme: this will always allocate memory. Intern? |
togayan | 0:1855a008f28e | 837 | text->SetCData( this->CData() ); |
togayan | 0:1855a008f28e | 838 | return text; |
togayan | 0:1855a008f28e | 839 | } |
togayan | 0:1855a008f28e | 840 | |
togayan | 0:1855a008f28e | 841 | |
togayan | 0:1855a008f28e | 842 | bool XMLText::ShallowEqual( const XMLNode* compare ) const |
togayan | 0:1855a008f28e | 843 | { |
togayan | 0:1855a008f28e | 844 | return ( compare->ToText() && XMLUtil::StringEqual( compare->ToText()->Value(), Value() )); |
togayan | 0:1855a008f28e | 845 | } |
togayan | 0:1855a008f28e | 846 | |
togayan | 0:1855a008f28e | 847 | |
togayan | 0:1855a008f28e | 848 | bool XMLText::Accept( XMLVisitor* visitor ) const |
togayan | 0:1855a008f28e | 849 | { |
togayan | 0:1855a008f28e | 850 | return visitor->Visit( *this ); |
togayan | 0:1855a008f28e | 851 | } |
togayan | 0:1855a008f28e | 852 | |
togayan | 0:1855a008f28e | 853 | |
togayan | 0:1855a008f28e | 854 | // --------- XMLComment ---------- // |
togayan | 0:1855a008f28e | 855 | |
togayan | 0:1855a008f28e | 856 | XMLComment::XMLComment( XMLDocument* doc ) : XMLNode( doc ) |
togayan | 0:1855a008f28e | 857 | { |
togayan | 0:1855a008f28e | 858 | } |
togayan | 0:1855a008f28e | 859 | |
togayan | 0:1855a008f28e | 860 | |
togayan | 0:1855a008f28e | 861 | XMLComment::~XMLComment() |
togayan | 0:1855a008f28e | 862 | { |
togayan | 0:1855a008f28e | 863 | //printf( "~XMLComment\n" ); |
togayan | 0:1855a008f28e | 864 | } |
togayan | 0:1855a008f28e | 865 | |
togayan | 0:1855a008f28e | 866 | |
togayan | 0:1855a008f28e | 867 | char* XMLComment::ParseDeep( char* p, StrPair* ) |
togayan | 0:1855a008f28e | 868 | { |
togayan | 0:1855a008f28e | 869 | // Comment parses as text. |
togayan | 0:1855a008f28e | 870 | const char* start = p; |
togayan | 0:1855a008f28e | 871 | p = value.ParseText( p, "-->", StrPair::COMMENT ); |
togayan | 0:1855a008f28e | 872 | if ( p == 0 ) { |
togayan | 0:1855a008f28e | 873 | document->SetError( XML_ERROR_PARSING_COMMENT, start, 0 ); |
togayan | 0:1855a008f28e | 874 | } |
togayan | 0:1855a008f28e | 875 | return p; |
togayan | 0:1855a008f28e | 876 | } |
togayan | 0:1855a008f28e | 877 | |
togayan | 0:1855a008f28e | 878 | |
togayan | 0:1855a008f28e | 879 | XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const |
togayan | 0:1855a008f28e | 880 | { |
togayan | 0:1855a008f28e | 881 | if ( !doc ) { |
togayan | 0:1855a008f28e | 882 | doc = document; |
togayan | 0:1855a008f28e | 883 | } |
togayan | 0:1855a008f28e | 884 | XMLComment* comment = doc->NewComment( Value() ); // fixme: this will always allocate memory. Intern? |
togayan | 0:1855a008f28e | 885 | return comment; |
togayan | 0:1855a008f28e | 886 | } |
togayan | 0:1855a008f28e | 887 | |
togayan | 0:1855a008f28e | 888 | |
togayan | 0:1855a008f28e | 889 | bool XMLComment::ShallowEqual( const XMLNode* compare ) const |
togayan | 0:1855a008f28e | 890 | { |
togayan | 0:1855a008f28e | 891 | return ( compare->ToComment() && XMLUtil::StringEqual( compare->ToComment()->Value(), Value() )); |
togayan | 0:1855a008f28e | 892 | } |
togayan | 0:1855a008f28e | 893 | |
togayan | 0:1855a008f28e | 894 | |
togayan | 0:1855a008f28e | 895 | bool XMLComment::Accept( XMLVisitor* visitor ) const |
togayan | 0:1855a008f28e | 896 | { |
togayan | 0:1855a008f28e | 897 | return visitor->Visit( *this ); |
togayan | 0:1855a008f28e | 898 | } |
togayan | 0:1855a008f28e | 899 | |
togayan | 0:1855a008f28e | 900 | |
togayan | 0:1855a008f28e | 901 | // --------- XMLDeclaration ---------- // |
togayan | 0:1855a008f28e | 902 | |
togayan | 0:1855a008f28e | 903 | XMLDeclaration::XMLDeclaration( XMLDocument* doc ) : XMLNode( doc ) |
togayan | 0:1855a008f28e | 904 | { |
togayan | 0:1855a008f28e | 905 | } |
togayan | 0:1855a008f28e | 906 | |
togayan | 0:1855a008f28e | 907 | |
togayan | 0:1855a008f28e | 908 | XMLDeclaration::~XMLDeclaration() |
togayan | 0:1855a008f28e | 909 | { |
togayan | 0:1855a008f28e | 910 | //printf( "~XMLDeclaration\n" ); |
togayan | 0:1855a008f28e | 911 | } |
togayan | 0:1855a008f28e | 912 | |
togayan | 0:1855a008f28e | 913 | |
togayan | 0:1855a008f28e | 914 | char* XMLDeclaration::ParseDeep( char* p, StrPair* ) |
togayan | 0:1855a008f28e | 915 | { |
togayan | 0:1855a008f28e | 916 | // Declaration parses as text. |
togayan | 0:1855a008f28e | 917 | const char* start = p; |
togayan | 0:1855a008f28e | 918 | p = value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION ); |
togayan | 0:1855a008f28e | 919 | if ( p == 0 ) { |
togayan | 0:1855a008f28e | 920 | document->SetError( XML_ERROR_PARSING_DECLARATION, start, 0 ); |
togayan | 0:1855a008f28e | 921 | } |
togayan | 0:1855a008f28e | 922 | return p; |
togayan | 0:1855a008f28e | 923 | } |
togayan | 0:1855a008f28e | 924 | |
togayan | 0:1855a008f28e | 925 | |
togayan | 0:1855a008f28e | 926 | XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const |
togayan | 0:1855a008f28e | 927 | { |
togayan | 0:1855a008f28e | 928 | if ( !doc ) { |
togayan | 0:1855a008f28e | 929 | doc = document; |
togayan | 0:1855a008f28e | 930 | } |
togayan | 0:1855a008f28e | 931 | XMLDeclaration* dec = doc->NewDeclaration( Value() ); // fixme: this will always allocate memory. Intern? |
togayan | 0:1855a008f28e | 932 | return dec; |
togayan | 0:1855a008f28e | 933 | } |
togayan | 0:1855a008f28e | 934 | |
togayan | 0:1855a008f28e | 935 | |
togayan | 0:1855a008f28e | 936 | bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const |
togayan | 0:1855a008f28e | 937 | { |
togayan | 0:1855a008f28e | 938 | return ( compare->ToDeclaration() && XMLUtil::StringEqual( compare->ToDeclaration()->Value(), Value() )); |
togayan | 0:1855a008f28e | 939 | } |
togayan | 0:1855a008f28e | 940 | |
togayan | 0:1855a008f28e | 941 | |
togayan | 0:1855a008f28e | 942 | |
togayan | 0:1855a008f28e | 943 | bool XMLDeclaration::Accept( XMLVisitor* visitor ) const |
togayan | 0:1855a008f28e | 944 | { |
togayan | 0:1855a008f28e | 945 | return visitor->Visit( *this ); |
togayan | 0:1855a008f28e | 946 | } |
togayan | 0:1855a008f28e | 947 | |
togayan | 0:1855a008f28e | 948 | // --------- XMLUnknown ---------- // |
togayan | 0:1855a008f28e | 949 | |
togayan | 0:1855a008f28e | 950 | XMLUnknown::XMLUnknown( XMLDocument* doc ) : XMLNode( doc ) |
togayan | 0:1855a008f28e | 951 | { |
togayan | 0:1855a008f28e | 952 | } |
togayan | 0:1855a008f28e | 953 | |
togayan | 0:1855a008f28e | 954 | |
togayan | 0:1855a008f28e | 955 | XMLUnknown::~XMLUnknown() |
togayan | 0:1855a008f28e | 956 | { |
togayan | 0:1855a008f28e | 957 | } |
togayan | 0:1855a008f28e | 958 | |
togayan | 0:1855a008f28e | 959 | |
togayan | 0:1855a008f28e | 960 | char* XMLUnknown::ParseDeep( char* p, StrPair* ) |
togayan | 0:1855a008f28e | 961 | { |
togayan | 0:1855a008f28e | 962 | // Unknown parses as text. |
togayan | 0:1855a008f28e | 963 | const char* start = p; |
togayan | 0:1855a008f28e | 964 | |
togayan | 0:1855a008f28e | 965 | p = value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION ); |
togayan | 0:1855a008f28e | 966 | if ( !p ) { |
togayan | 0:1855a008f28e | 967 | document->SetError( XML_ERROR_PARSING_UNKNOWN, start, 0 ); |
togayan | 0:1855a008f28e | 968 | } |
togayan | 0:1855a008f28e | 969 | return p; |
togayan | 0:1855a008f28e | 970 | } |
togayan | 0:1855a008f28e | 971 | |
togayan | 0:1855a008f28e | 972 | |
togayan | 0:1855a008f28e | 973 | XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const |
togayan | 0:1855a008f28e | 974 | { |
togayan | 0:1855a008f28e | 975 | if ( !doc ) { |
togayan | 0:1855a008f28e | 976 | doc = document; |
togayan | 0:1855a008f28e | 977 | } |
togayan | 0:1855a008f28e | 978 | XMLUnknown* text = doc->NewUnknown( Value() ); // fixme: this will always allocate memory. Intern? |
togayan | 0:1855a008f28e | 979 | return text; |
togayan | 0:1855a008f28e | 980 | } |
togayan | 0:1855a008f28e | 981 | |
togayan | 0:1855a008f28e | 982 | |
togayan | 0:1855a008f28e | 983 | bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const |
togayan | 0:1855a008f28e | 984 | { |
togayan | 0:1855a008f28e | 985 | return ( compare->ToUnknown() && XMLUtil::StringEqual( compare->ToUnknown()->Value(), Value() )); |
togayan | 0:1855a008f28e | 986 | } |
togayan | 0:1855a008f28e | 987 | |
togayan | 0:1855a008f28e | 988 | |
togayan | 0:1855a008f28e | 989 | bool XMLUnknown::Accept( XMLVisitor* visitor ) const |
togayan | 0:1855a008f28e | 990 | { |
togayan | 0:1855a008f28e | 991 | return visitor->Visit( *this ); |
togayan | 0:1855a008f28e | 992 | } |
togayan | 0:1855a008f28e | 993 | |
togayan | 0:1855a008f28e | 994 | // --------- XMLAttribute ---------- // |
togayan | 0:1855a008f28e | 995 | char* XMLAttribute::ParseDeep( char* p, bool processEntities ) |
togayan | 0:1855a008f28e | 996 | { |
togayan | 0:1855a008f28e | 997 | // Parse using the name rules: bug fix, was using ParseText before |
togayan | 0:1855a008f28e | 998 | p = name.ParseName( p ); |
togayan | 0:1855a008f28e | 999 | if ( !p || !*p ) return 0; |
togayan | 0:1855a008f28e | 1000 | |
togayan | 0:1855a008f28e | 1001 | // Skip white space before = |
togayan | 0:1855a008f28e | 1002 | p = XMLUtil::SkipWhiteSpace( p ); |
togayan | 0:1855a008f28e | 1003 | if ( !p || *p != '=' ) return 0; |
togayan | 0:1855a008f28e | 1004 | |
togayan | 0:1855a008f28e | 1005 | ++p; // move up to opening quote |
togayan | 0:1855a008f28e | 1006 | p = XMLUtil::SkipWhiteSpace( p ); |
togayan | 0:1855a008f28e | 1007 | if ( *p != '\"' && *p != '\'' ) return 0; |
togayan | 0:1855a008f28e | 1008 | |
togayan | 0:1855a008f28e | 1009 | char endTag[2] = { *p, 0 }; |
togayan | 0:1855a008f28e | 1010 | ++p; // move past opening quote |
togayan | 0:1855a008f28e | 1011 | |
togayan | 0:1855a008f28e | 1012 | p = value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES ); |
togayan | 0:1855a008f28e | 1013 | return p; |
togayan | 0:1855a008f28e | 1014 | } |
togayan | 0:1855a008f28e | 1015 | |
togayan | 0:1855a008f28e | 1016 | |
togayan | 0:1855a008f28e | 1017 | void XMLAttribute::SetName( const char* n ) |
togayan | 0:1855a008f28e | 1018 | { |
togayan | 0:1855a008f28e | 1019 | name.SetStr( n ); |
togayan | 0:1855a008f28e | 1020 | } |
togayan | 0:1855a008f28e | 1021 | |
togayan | 0:1855a008f28e | 1022 | |
togayan | 0:1855a008f28e | 1023 | int XMLAttribute::QueryIntValue( int* value ) const |
togayan | 0:1855a008f28e | 1024 | { |
togayan | 0:1855a008f28e | 1025 | if ( XMLUtil::ToInt( Value(), value )) |
togayan | 0:1855a008f28e | 1026 | return XML_NO_ERROR; |
togayan | 0:1855a008f28e | 1027 | return XML_WRONG_ATTRIBUTE_TYPE; |
togayan | 0:1855a008f28e | 1028 | } |
togayan | 0:1855a008f28e | 1029 | |
togayan | 0:1855a008f28e | 1030 | |
togayan | 0:1855a008f28e | 1031 | int XMLAttribute::QueryUnsignedValue( unsigned int* value ) const |
togayan | 0:1855a008f28e | 1032 | { |
togayan | 0:1855a008f28e | 1033 | if ( XMLUtil::ToUnsigned( Value(), value )) |
togayan | 0:1855a008f28e | 1034 | return XML_NO_ERROR; |
togayan | 0:1855a008f28e | 1035 | return XML_WRONG_ATTRIBUTE_TYPE; |
togayan | 0:1855a008f28e | 1036 | } |
togayan | 0:1855a008f28e | 1037 | |
togayan | 0:1855a008f28e | 1038 | |
togayan | 0:1855a008f28e | 1039 | int XMLAttribute::QueryBoolValue( bool* value ) const |
togayan | 0:1855a008f28e | 1040 | { |
togayan | 0:1855a008f28e | 1041 | if ( XMLUtil::ToBool( Value(), value )) { |
togayan | 0:1855a008f28e | 1042 | return XML_NO_ERROR; |
togayan | 0:1855a008f28e | 1043 | } |
togayan | 0:1855a008f28e | 1044 | return XML_WRONG_ATTRIBUTE_TYPE; |
togayan | 0:1855a008f28e | 1045 | } |
togayan | 0:1855a008f28e | 1046 | |
togayan | 0:1855a008f28e | 1047 | |
togayan | 0:1855a008f28e | 1048 | int XMLAttribute::QueryFloatValue( float* value ) const |
togayan | 0:1855a008f28e | 1049 | { |
togayan | 0:1855a008f28e | 1050 | if ( XMLUtil::ToFloat( Value(), value )) |
togayan | 0:1855a008f28e | 1051 | return XML_NO_ERROR; |
togayan | 0:1855a008f28e | 1052 | return XML_WRONG_ATTRIBUTE_TYPE; |
togayan | 0:1855a008f28e | 1053 | } |
togayan | 0:1855a008f28e | 1054 | |
togayan | 0:1855a008f28e | 1055 | |
togayan | 0:1855a008f28e | 1056 | int XMLAttribute::QueryDoubleValue( double* value ) const |
togayan | 0:1855a008f28e | 1057 | { |
togayan | 0:1855a008f28e | 1058 | if ( XMLUtil::ToDouble( Value(), value )) |
togayan | 0:1855a008f28e | 1059 | return XML_NO_ERROR; |
togayan | 0:1855a008f28e | 1060 | return XML_WRONG_ATTRIBUTE_TYPE; |
togayan | 0:1855a008f28e | 1061 | } |
togayan | 0:1855a008f28e | 1062 | |
togayan | 0:1855a008f28e | 1063 | |
togayan | 0:1855a008f28e | 1064 | void XMLAttribute::SetAttribute( const char* v ) |
togayan | 0:1855a008f28e | 1065 | { |
togayan | 0:1855a008f28e | 1066 | value.SetStr( v ); |
togayan | 0:1855a008f28e | 1067 | } |
togayan | 0:1855a008f28e | 1068 | |
togayan | 0:1855a008f28e | 1069 | |
togayan | 0:1855a008f28e | 1070 | void XMLAttribute::SetAttribute( int v ) |
togayan | 0:1855a008f28e | 1071 | { |
togayan | 0:1855a008f28e | 1072 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1073 | XMLUtil::ToStr( v, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1074 | value.SetStr( buf ); |
togayan | 0:1855a008f28e | 1075 | } |
togayan | 0:1855a008f28e | 1076 | |
togayan | 0:1855a008f28e | 1077 | |
togayan | 0:1855a008f28e | 1078 | void XMLAttribute::SetAttribute( unsigned v ) |
togayan | 0:1855a008f28e | 1079 | { |
togayan | 0:1855a008f28e | 1080 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1081 | XMLUtil::ToStr( v, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1082 | value.SetStr( buf ); |
togayan | 0:1855a008f28e | 1083 | } |
togayan | 0:1855a008f28e | 1084 | |
togayan | 0:1855a008f28e | 1085 | |
togayan | 0:1855a008f28e | 1086 | void XMLAttribute::SetAttribute( bool v ) |
togayan | 0:1855a008f28e | 1087 | { |
togayan | 0:1855a008f28e | 1088 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1089 | XMLUtil::ToStr( v, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1090 | value.SetStr( buf ); |
togayan | 0:1855a008f28e | 1091 | } |
togayan | 0:1855a008f28e | 1092 | |
togayan | 0:1855a008f28e | 1093 | void XMLAttribute::SetAttribute( double v ) |
togayan | 0:1855a008f28e | 1094 | { |
togayan | 0:1855a008f28e | 1095 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1096 | XMLUtil::ToStr( v, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1097 | value.SetStr( buf ); |
togayan | 0:1855a008f28e | 1098 | } |
togayan | 0:1855a008f28e | 1099 | |
togayan | 0:1855a008f28e | 1100 | void XMLAttribute::SetAttribute( float v ) |
togayan | 0:1855a008f28e | 1101 | { |
togayan | 0:1855a008f28e | 1102 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1103 | XMLUtil::ToStr( v, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1104 | value.SetStr( buf ); |
togayan | 0:1855a008f28e | 1105 | } |
togayan | 0:1855a008f28e | 1106 | |
togayan | 0:1855a008f28e | 1107 | |
togayan | 0:1855a008f28e | 1108 | // --------- XMLElement ---------- // |
togayan | 0:1855a008f28e | 1109 | XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ), |
togayan | 0:1855a008f28e | 1110 | closingType( 0 ), |
togayan | 0:1855a008f28e | 1111 | rootAttribute( 0 ) |
togayan | 0:1855a008f28e | 1112 | { |
togayan | 0:1855a008f28e | 1113 | } |
togayan | 0:1855a008f28e | 1114 | |
togayan | 0:1855a008f28e | 1115 | |
togayan | 0:1855a008f28e | 1116 | XMLElement::~XMLElement() |
togayan | 0:1855a008f28e | 1117 | { |
togayan | 0:1855a008f28e | 1118 | while( rootAttribute ) { |
togayan | 0:1855a008f28e | 1119 | XMLAttribute* next = rootAttribute->next; |
togayan | 0:1855a008f28e | 1120 | DELETE_ATTRIBUTE( rootAttribute ); |
togayan | 0:1855a008f28e | 1121 | rootAttribute = next; |
togayan | 0:1855a008f28e | 1122 | } |
togayan | 0:1855a008f28e | 1123 | } |
togayan | 0:1855a008f28e | 1124 | |
togayan | 0:1855a008f28e | 1125 | |
togayan | 0:1855a008f28e | 1126 | XMLAttribute* XMLElement::FindAttribute( const char* name ) |
togayan | 0:1855a008f28e | 1127 | { |
togayan | 0:1855a008f28e | 1128 | XMLAttribute* a = 0; |
togayan | 0:1855a008f28e | 1129 | for( a=rootAttribute; a; a = a->next ) { |
togayan | 0:1855a008f28e | 1130 | if ( XMLUtil::StringEqual( a->Name(), name ) ) |
togayan | 0:1855a008f28e | 1131 | return a; |
togayan | 0:1855a008f28e | 1132 | } |
togayan | 0:1855a008f28e | 1133 | return 0; |
togayan | 0:1855a008f28e | 1134 | } |
togayan | 0:1855a008f28e | 1135 | |
togayan | 0:1855a008f28e | 1136 | |
togayan | 0:1855a008f28e | 1137 | const XMLAttribute* XMLElement::FindAttribute( const char* name ) const |
togayan | 0:1855a008f28e | 1138 | { |
togayan | 0:1855a008f28e | 1139 | XMLAttribute* a = 0; |
togayan | 0:1855a008f28e | 1140 | for( a=rootAttribute; a; a = a->next ) { |
togayan | 0:1855a008f28e | 1141 | if ( XMLUtil::StringEqual( a->Name(), name ) ) |
togayan | 0:1855a008f28e | 1142 | return a; |
togayan | 0:1855a008f28e | 1143 | } |
togayan | 0:1855a008f28e | 1144 | return 0; |
togayan | 0:1855a008f28e | 1145 | } |
togayan | 0:1855a008f28e | 1146 | |
togayan | 0:1855a008f28e | 1147 | |
togayan | 0:1855a008f28e | 1148 | const char* XMLElement::Attribute( const char* name, const char* value ) const |
togayan | 0:1855a008f28e | 1149 | { |
togayan | 0:1855a008f28e | 1150 | const XMLAttribute* a = FindAttribute( name ); |
togayan | 0:1855a008f28e | 1151 | if ( !a ) |
togayan | 0:1855a008f28e | 1152 | return 0; |
togayan | 0:1855a008f28e | 1153 | if ( !value || XMLUtil::StringEqual( a->Value(), value )) |
togayan | 0:1855a008f28e | 1154 | return a->Value(); |
togayan | 0:1855a008f28e | 1155 | return 0; |
togayan | 0:1855a008f28e | 1156 | } |
togayan | 0:1855a008f28e | 1157 | |
togayan | 0:1855a008f28e | 1158 | |
togayan | 0:1855a008f28e | 1159 | const char* XMLElement::GetText() const |
togayan | 0:1855a008f28e | 1160 | { |
togayan | 0:1855a008f28e | 1161 | if ( FirstChild() && FirstChild()->ToText() ) { |
togayan | 0:1855a008f28e | 1162 | return FirstChild()->ToText()->Value(); |
togayan | 0:1855a008f28e | 1163 | } |
togayan | 0:1855a008f28e | 1164 | return 0; |
togayan | 0:1855a008f28e | 1165 | } |
togayan | 0:1855a008f28e | 1166 | |
togayan | 0:1855a008f28e | 1167 | |
togayan | 0:1855a008f28e | 1168 | int XMLElement::QueryIntText( int* _value ) const |
togayan | 0:1855a008f28e | 1169 | { |
togayan | 0:1855a008f28e | 1170 | if ( FirstChild() && FirstChild()->ToText() ) { |
togayan | 0:1855a008f28e | 1171 | const char* t = FirstChild()->ToText()->Value(); |
togayan | 0:1855a008f28e | 1172 | if ( XMLUtil::ToInt( t, _value ) ) { |
togayan | 0:1855a008f28e | 1173 | return XML_SUCCESS; |
togayan | 0:1855a008f28e | 1174 | } |
togayan | 0:1855a008f28e | 1175 | return XML_CAN_NOT_CONVERT_TEXT; |
togayan | 0:1855a008f28e | 1176 | } |
togayan | 0:1855a008f28e | 1177 | return XML_NO_TEXT_NODE; |
togayan | 0:1855a008f28e | 1178 | } |
togayan | 0:1855a008f28e | 1179 | |
togayan | 0:1855a008f28e | 1180 | |
togayan | 0:1855a008f28e | 1181 | int XMLElement::QueryUnsignedText( unsigned* _value ) const |
togayan | 0:1855a008f28e | 1182 | { |
togayan | 0:1855a008f28e | 1183 | if ( FirstChild() && FirstChild()->ToText() ) { |
togayan | 0:1855a008f28e | 1184 | const char* t = FirstChild()->ToText()->Value(); |
togayan | 0:1855a008f28e | 1185 | if ( XMLUtil::ToUnsigned( t, _value ) ) { |
togayan | 0:1855a008f28e | 1186 | return XML_SUCCESS; |
togayan | 0:1855a008f28e | 1187 | } |
togayan | 0:1855a008f28e | 1188 | return XML_CAN_NOT_CONVERT_TEXT; |
togayan | 0:1855a008f28e | 1189 | } |
togayan | 0:1855a008f28e | 1190 | return XML_NO_TEXT_NODE; |
togayan | 0:1855a008f28e | 1191 | } |
togayan | 0:1855a008f28e | 1192 | |
togayan | 0:1855a008f28e | 1193 | |
togayan | 0:1855a008f28e | 1194 | int XMLElement::QueryBoolText( bool* _value ) const |
togayan | 0:1855a008f28e | 1195 | { |
togayan | 0:1855a008f28e | 1196 | if ( FirstChild() && FirstChild()->ToText() ) { |
togayan | 0:1855a008f28e | 1197 | const char* t = FirstChild()->ToText()->Value(); |
togayan | 0:1855a008f28e | 1198 | if ( XMLUtil::ToBool( t, _value ) ) { |
togayan | 0:1855a008f28e | 1199 | return XML_SUCCESS; |
togayan | 0:1855a008f28e | 1200 | } |
togayan | 0:1855a008f28e | 1201 | return XML_CAN_NOT_CONVERT_TEXT; |
togayan | 0:1855a008f28e | 1202 | } |
togayan | 0:1855a008f28e | 1203 | return XML_NO_TEXT_NODE; |
togayan | 0:1855a008f28e | 1204 | } |
togayan | 0:1855a008f28e | 1205 | |
togayan | 0:1855a008f28e | 1206 | |
togayan | 0:1855a008f28e | 1207 | int XMLElement::QueryDoubleText( double* _value ) const |
togayan | 0:1855a008f28e | 1208 | { |
togayan | 0:1855a008f28e | 1209 | if ( FirstChild() && FirstChild()->ToText() ) { |
togayan | 0:1855a008f28e | 1210 | const char* t = FirstChild()->ToText()->Value(); |
togayan | 0:1855a008f28e | 1211 | if ( XMLUtil::ToDouble( t, _value ) ) { |
togayan | 0:1855a008f28e | 1212 | return XML_SUCCESS; |
togayan | 0:1855a008f28e | 1213 | } |
togayan | 0:1855a008f28e | 1214 | return XML_CAN_NOT_CONVERT_TEXT; |
togayan | 0:1855a008f28e | 1215 | } |
togayan | 0:1855a008f28e | 1216 | return XML_NO_TEXT_NODE; |
togayan | 0:1855a008f28e | 1217 | } |
togayan | 0:1855a008f28e | 1218 | |
togayan | 0:1855a008f28e | 1219 | |
togayan | 0:1855a008f28e | 1220 | int XMLElement::QueryFloatText( float* _value ) const |
togayan | 0:1855a008f28e | 1221 | { |
togayan | 0:1855a008f28e | 1222 | if ( FirstChild() && FirstChild()->ToText() ) { |
togayan | 0:1855a008f28e | 1223 | const char* t = FirstChild()->ToText()->Value(); |
togayan | 0:1855a008f28e | 1224 | if ( XMLUtil::ToFloat( t, _value ) ) { |
togayan | 0:1855a008f28e | 1225 | return XML_SUCCESS; |
togayan | 0:1855a008f28e | 1226 | } |
togayan | 0:1855a008f28e | 1227 | return XML_CAN_NOT_CONVERT_TEXT; |
togayan | 0:1855a008f28e | 1228 | } |
togayan | 0:1855a008f28e | 1229 | return XML_NO_TEXT_NODE; |
togayan | 0:1855a008f28e | 1230 | } |
togayan | 0:1855a008f28e | 1231 | |
togayan | 0:1855a008f28e | 1232 | |
togayan | 0:1855a008f28e | 1233 | |
togayan | 0:1855a008f28e | 1234 | XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name ) |
togayan | 0:1855a008f28e | 1235 | { |
togayan | 0:1855a008f28e | 1236 | XMLAttribute* last = 0; |
togayan | 0:1855a008f28e | 1237 | XMLAttribute* attrib = 0; |
togayan | 0:1855a008f28e | 1238 | for( attrib = rootAttribute; |
togayan | 0:1855a008f28e | 1239 | attrib; |
togayan | 0:1855a008f28e | 1240 | last = attrib, attrib = attrib->next ) |
togayan | 0:1855a008f28e | 1241 | { |
togayan | 0:1855a008f28e | 1242 | if ( XMLUtil::StringEqual( attrib->Name(), name ) ) { |
togayan | 0:1855a008f28e | 1243 | break; |
togayan | 0:1855a008f28e | 1244 | } |
togayan | 0:1855a008f28e | 1245 | } |
togayan | 0:1855a008f28e | 1246 | if ( !attrib ) { |
togayan | 0:1855a008f28e | 1247 | attrib = new (document->attributePool.Alloc() ) XMLAttribute(); |
togayan | 0:1855a008f28e | 1248 | attrib->memPool = &document->attributePool; |
togayan | 0:1855a008f28e | 1249 | if ( last ) { |
togayan | 0:1855a008f28e | 1250 | last->next = attrib; |
togayan | 0:1855a008f28e | 1251 | } |
togayan | 0:1855a008f28e | 1252 | else { |
togayan | 0:1855a008f28e | 1253 | rootAttribute = attrib; |
togayan | 0:1855a008f28e | 1254 | } |
togayan | 0:1855a008f28e | 1255 | attrib->SetName( name ); |
togayan | 0:1855a008f28e | 1256 | } |
togayan | 0:1855a008f28e | 1257 | return attrib; |
togayan | 0:1855a008f28e | 1258 | } |
togayan | 0:1855a008f28e | 1259 | |
togayan | 0:1855a008f28e | 1260 | |
togayan | 0:1855a008f28e | 1261 | void XMLElement::DeleteAttribute( const char* name ) |
togayan | 0:1855a008f28e | 1262 | { |
togayan | 0:1855a008f28e | 1263 | XMLAttribute* prev = 0; |
togayan | 0:1855a008f28e | 1264 | for( XMLAttribute* a=rootAttribute; a; a=a->next ) { |
togayan | 0:1855a008f28e | 1265 | if ( XMLUtil::StringEqual( name, a->Name() ) ) { |
togayan | 0:1855a008f28e | 1266 | if ( prev ) { |
togayan | 0:1855a008f28e | 1267 | prev->next = a->next; |
togayan | 0:1855a008f28e | 1268 | } |
togayan | 0:1855a008f28e | 1269 | else { |
togayan | 0:1855a008f28e | 1270 | rootAttribute = a->next; |
togayan | 0:1855a008f28e | 1271 | } |
togayan | 0:1855a008f28e | 1272 | DELETE_ATTRIBUTE( a ); |
togayan | 0:1855a008f28e | 1273 | break; |
togayan | 0:1855a008f28e | 1274 | } |
togayan | 0:1855a008f28e | 1275 | prev = a; |
togayan | 0:1855a008f28e | 1276 | } |
togayan | 0:1855a008f28e | 1277 | } |
togayan | 0:1855a008f28e | 1278 | |
togayan | 0:1855a008f28e | 1279 | |
togayan | 0:1855a008f28e | 1280 | char* XMLElement::ParseAttributes( char* p ) |
togayan | 0:1855a008f28e | 1281 | { |
togayan | 0:1855a008f28e | 1282 | const char* start = p; |
togayan | 0:1855a008f28e | 1283 | XMLAttribute* prevAttribute = 0; |
togayan | 0:1855a008f28e | 1284 | |
togayan | 0:1855a008f28e | 1285 | // Read the attributes. |
togayan | 0:1855a008f28e | 1286 | while( p ) { |
togayan | 0:1855a008f28e | 1287 | p = XMLUtil::SkipWhiteSpace( p ); |
togayan | 0:1855a008f28e | 1288 | if ( !p || !(*p) ) { |
togayan | 0:1855a008f28e | 1289 | document->SetError( XML_ERROR_PARSING_ELEMENT, start, Name() ); |
togayan | 0:1855a008f28e | 1290 | return 0; |
togayan | 0:1855a008f28e | 1291 | } |
togayan | 0:1855a008f28e | 1292 | |
togayan | 0:1855a008f28e | 1293 | // attribute. |
togayan | 0:1855a008f28e | 1294 | if ( XMLUtil::IsAlpha( *p ) ) { |
togayan | 0:1855a008f28e | 1295 | XMLAttribute* attrib = new (document->attributePool.Alloc() ) XMLAttribute(); |
togayan | 0:1855a008f28e | 1296 | attrib->memPool = &document->attributePool; |
togayan | 0:1855a008f28e | 1297 | |
togayan | 0:1855a008f28e | 1298 | p = attrib->ParseDeep( p, document->ProcessEntities() ); |
togayan | 0:1855a008f28e | 1299 | if ( !p || Attribute( attrib->Name() ) ) { |
togayan | 0:1855a008f28e | 1300 | DELETE_ATTRIBUTE( attrib ); |
togayan | 0:1855a008f28e | 1301 | document->SetError( XML_ERROR_PARSING_ATTRIBUTE, start, p ); |
togayan | 0:1855a008f28e | 1302 | return 0; |
togayan | 0:1855a008f28e | 1303 | } |
togayan | 0:1855a008f28e | 1304 | // There is a minor bug here: if the attribute in the source xml |
togayan | 0:1855a008f28e | 1305 | // document is duplicated, it will not be detected and the |
togayan | 0:1855a008f28e | 1306 | // attribute will be doubly added. However, tracking the 'prevAttribute' |
togayan | 0:1855a008f28e | 1307 | // avoids re-scanning the attribute list. Preferring performance for |
togayan | 0:1855a008f28e | 1308 | // now, may reconsider in the future. |
togayan | 0:1855a008f28e | 1309 | if ( prevAttribute ) { |
togayan | 0:1855a008f28e | 1310 | prevAttribute->next = attrib; |
togayan | 0:1855a008f28e | 1311 | } |
togayan | 0:1855a008f28e | 1312 | else { |
togayan | 0:1855a008f28e | 1313 | rootAttribute = attrib; |
togayan | 0:1855a008f28e | 1314 | } |
togayan | 0:1855a008f28e | 1315 | prevAttribute = attrib; |
togayan | 0:1855a008f28e | 1316 | } |
togayan | 0:1855a008f28e | 1317 | // end of the tag |
togayan | 0:1855a008f28e | 1318 | else if ( *p == '/' && *(p+1) == '>' ) { |
togayan | 0:1855a008f28e | 1319 | closingType = CLOSED; |
togayan | 0:1855a008f28e | 1320 | return p+2; // done; sealed element. |
togayan | 0:1855a008f28e | 1321 | } |
togayan | 0:1855a008f28e | 1322 | // end of the tag |
togayan | 0:1855a008f28e | 1323 | else if ( *p == '>' ) { |
togayan | 0:1855a008f28e | 1324 | ++p; |
togayan | 0:1855a008f28e | 1325 | break; |
togayan | 0:1855a008f28e | 1326 | } |
togayan | 0:1855a008f28e | 1327 | else { |
togayan | 0:1855a008f28e | 1328 | document->SetError( XML_ERROR_PARSING_ELEMENT, start, p ); |
togayan | 0:1855a008f28e | 1329 | return 0; |
togayan | 0:1855a008f28e | 1330 | } |
togayan | 0:1855a008f28e | 1331 | } |
togayan | 0:1855a008f28e | 1332 | return p; |
togayan | 0:1855a008f28e | 1333 | } |
togayan | 0:1855a008f28e | 1334 | |
togayan | 0:1855a008f28e | 1335 | |
togayan | 0:1855a008f28e | 1336 | // |
togayan | 0:1855a008f28e | 1337 | // <ele></ele> |
togayan | 0:1855a008f28e | 1338 | // <ele>foo<b>bar</b></ele> |
togayan | 0:1855a008f28e | 1339 | // |
togayan | 0:1855a008f28e | 1340 | char* XMLElement::ParseDeep( char* p, StrPair* strPair ) |
togayan | 0:1855a008f28e | 1341 | { |
togayan | 0:1855a008f28e | 1342 | // Read the element name. |
togayan | 0:1855a008f28e | 1343 | p = XMLUtil::SkipWhiteSpace( p ); |
togayan | 0:1855a008f28e | 1344 | if ( !p ) return 0; |
togayan | 0:1855a008f28e | 1345 | |
togayan | 0:1855a008f28e | 1346 | // The closing element is the </element> form. It is |
togayan | 0:1855a008f28e | 1347 | // parsed just like a regular element then deleted from |
togayan | 0:1855a008f28e | 1348 | // the DOM. |
togayan | 0:1855a008f28e | 1349 | if ( *p == '/' ) { |
togayan | 0:1855a008f28e | 1350 | closingType = CLOSING; |
togayan | 0:1855a008f28e | 1351 | ++p; |
togayan | 0:1855a008f28e | 1352 | } |
togayan | 0:1855a008f28e | 1353 | |
togayan | 0:1855a008f28e | 1354 | p = value.ParseName( p ); |
togayan | 0:1855a008f28e | 1355 | if ( value.Empty() ) return 0; |
togayan | 0:1855a008f28e | 1356 | |
togayan | 0:1855a008f28e | 1357 | p = ParseAttributes( p ); |
togayan | 0:1855a008f28e | 1358 | if ( !p || !*p || closingType ) |
togayan | 0:1855a008f28e | 1359 | return p; |
togayan | 0:1855a008f28e | 1360 | |
togayan | 0:1855a008f28e | 1361 | p = XMLNode::ParseDeep( p, strPair ); |
togayan | 0:1855a008f28e | 1362 | return p; |
togayan | 0:1855a008f28e | 1363 | } |
togayan | 0:1855a008f28e | 1364 | |
togayan | 0:1855a008f28e | 1365 | |
togayan | 0:1855a008f28e | 1366 | |
togayan | 0:1855a008f28e | 1367 | XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const |
togayan | 0:1855a008f28e | 1368 | { |
togayan | 0:1855a008f28e | 1369 | if ( !doc ) { |
togayan | 0:1855a008f28e | 1370 | doc = document; |
togayan | 0:1855a008f28e | 1371 | } |
togayan | 0:1855a008f28e | 1372 | XMLElement* element = doc->NewElement( Value() ); // fixme: this will always allocate memory. Intern? |
togayan | 0:1855a008f28e | 1373 | for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) { |
togayan | 0:1855a008f28e | 1374 | element->SetAttribute( a->Name(), a->Value() ); // fixme: this will always allocate memory. Intern? |
togayan | 0:1855a008f28e | 1375 | } |
togayan | 0:1855a008f28e | 1376 | return element; |
togayan | 0:1855a008f28e | 1377 | } |
togayan | 0:1855a008f28e | 1378 | |
togayan | 0:1855a008f28e | 1379 | |
togayan | 0:1855a008f28e | 1380 | bool XMLElement::ShallowEqual( const XMLNode* compare ) const |
togayan | 0:1855a008f28e | 1381 | { |
togayan | 0:1855a008f28e | 1382 | const XMLElement* other = compare->ToElement(); |
togayan | 0:1855a008f28e | 1383 | if ( other && XMLUtil::StringEqual( other->Value(), Value() )) { |
togayan | 0:1855a008f28e | 1384 | |
togayan | 0:1855a008f28e | 1385 | const XMLAttribute* a=FirstAttribute(); |
togayan | 0:1855a008f28e | 1386 | const XMLAttribute* b=other->FirstAttribute(); |
togayan | 0:1855a008f28e | 1387 | |
togayan | 0:1855a008f28e | 1388 | while ( a && b ) { |
togayan | 0:1855a008f28e | 1389 | if ( !XMLUtil::StringEqual( a->Value(), b->Value() ) ) { |
togayan | 0:1855a008f28e | 1390 | return false; |
togayan | 0:1855a008f28e | 1391 | } |
togayan | 0:1855a008f28e | 1392 | a = a->Next(); |
togayan | 0:1855a008f28e | 1393 | b = b->Next(); |
togayan | 0:1855a008f28e | 1394 | } |
togayan | 0:1855a008f28e | 1395 | if ( a || b ) { |
togayan | 0:1855a008f28e | 1396 | // different count |
togayan | 0:1855a008f28e | 1397 | return false; |
togayan | 0:1855a008f28e | 1398 | } |
togayan | 0:1855a008f28e | 1399 | return true; |
togayan | 0:1855a008f28e | 1400 | } |
togayan | 0:1855a008f28e | 1401 | return false; |
togayan | 0:1855a008f28e | 1402 | } |
togayan | 0:1855a008f28e | 1403 | |
togayan | 0:1855a008f28e | 1404 | |
togayan | 0:1855a008f28e | 1405 | bool XMLElement::Accept( XMLVisitor* visitor ) const |
togayan | 0:1855a008f28e | 1406 | { |
togayan | 0:1855a008f28e | 1407 | if ( visitor->VisitEnter( *this, rootAttribute ) ) |
togayan | 0:1855a008f28e | 1408 | { |
togayan | 0:1855a008f28e | 1409 | for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) |
togayan | 0:1855a008f28e | 1410 | { |
togayan | 0:1855a008f28e | 1411 | if ( !node->Accept( visitor ) ) |
togayan | 0:1855a008f28e | 1412 | break; |
togayan | 0:1855a008f28e | 1413 | } |
togayan | 0:1855a008f28e | 1414 | } |
togayan | 0:1855a008f28e | 1415 | return visitor->VisitExit( *this ); |
togayan | 0:1855a008f28e | 1416 | } |
togayan | 0:1855a008f28e | 1417 | |
togayan | 0:1855a008f28e | 1418 | |
togayan | 0:1855a008f28e | 1419 | // --------- XMLDocument ----------- // |
togayan | 0:1855a008f28e | 1420 | XMLDocument::XMLDocument( bool _processEntities ) : |
togayan | 0:1855a008f28e | 1421 | XMLNode( 0 ), |
togayan | 0:1855a008f28e | 1422 | writeBOM( false ), |
togayan | 0:1855a008f28e | 1423 | processEntities( _processEntities ), |
togayan | 0:1855a008f28e | 1424 | errorID( 0 ), |
togayan | 0:1855a008f28e | 1425 | errorStr1( 0 ), |
togayan | 0:1855a008f28e | 1426 | errorStr2( 0 ), |
togayan | 0:1855a008f28e | 1427 | charBuffer( 0 ) |
togayan | 0:1855a008f28e | 1428 | { |
togayan | 0:1855a008f28e | 1429 | document = this; // avoid warning about 'this' in initializer list |
togayan | 0:1855a008f28e | 1430 | } |
togayan | 0:1855a008f28e | 1431 | |
togayan | 0:1855a008f28e | 1432 | |
togayan | 0:1855a008f28e | 1433 | XMLDocument::~XMLDocument() |
togayan | 0:1855a008f28e | 1434 | { |
togayan | 0:1855a008f28e | 1435 | DeleteChildren(); |
togayan | 0:1855a008f28e | 1436 | delete [] charBuffer; |
togayan | 0:1855a008f28e | 1437 | |
togayan | 0:1855a008f28e | 1438 | #if 0 |
togayan | 0:1855a008f28e | 1439 | textPool.Trace( "text" ); |
togayan | 0:1855a008f28e | 1440 | elementPool.Trace( "element" ); |
togayan | 0:1855a008f28e | 1441 | commentPool.Trace( "comment" ); |
togayan | 0:1855a008f28e | 1442 | attributePool.Trace( "attribute" ); |
togayan | 0:1855a008f28e | 1443 | #endif |
togayan | 0:1855a008f28e | 1444 | |
togayan | 0:1855a008f28e | 1445 | TIXMLASSERT( textPool.CurrentAllocs() == 0 ); |
togayan | 0:1855a008f28e | 1446 | TIXMLASSERT( elementPool.CurrentAllocs() == 0 ); |
togayan | 0:1855a008f28e | 1447 | TIXMLASSERT( commentPool.CurrentAllocs() == 0 ); |
togayan | 0:1855a008f28e | 1448 | TIXMLASSERT( attributePool.CurrentAllocs() == 0 ); |
togayan | 0:1855a008f28e | 1449 | } |
togayan | 0:1855a008f28e | 1450 | |
togayan | 0:1855a008f28e | 1451 | |
togayan | 0:1855a008f28e | 1452 | void XMLDocument::InitDocument() |
togayan | 0:1855a008f28e | 1453 | { |
togayan | 0:1855a008f28e | 1454 | errorID = XML_NO_ERROR; |
togayan | 0:1855a008f28e | 1455 | errorStr1 = 0; |
togayan | 0:1855a008f28e | 1456 | errorStr2 = 0; |
togayan | 0:1855a008f28e | 1457 | |
togayan | 0:1855a008f28e | 1458 | delete [] charBuffer; |
togayan | 0:1855a008f28e | 1459 | charBuffer = 0; |
togayan | 0:1855a008f28e | 1460 | |
togayan | 0:1855a008f28e | 1461 | } |
togayan | 0:1855a008f28e | 1462 | |
togayan | 0:1855a008f28e | 1463 | |
togayan | 0:1855a008f28e | 1464 | XMLElement* XMLDocument::NewElement( const char* name ) |
togayan | 0:1855a008f28e | 1465 | { |
togayan | 0:1855a008f28e | 1466 | XMLElement* ele = new (elementPool.Alloc()) XMLElement( this ); |
togayan | 0:1855a008f28e | 1467 | ele->memPool = &elementPool; |
togayan | 0:1855a008f28e | 1468 | ele->SetName( name ); |
togayan | 0:1855a008f28e | 1469 | return ele; |
togayan | 0:1855a008f28e | 1470 | } |
togayan | 0:1855a008f28e | 1471 | |
togayan | 0:1855a008f28e | 1472 | |
togayan | 0:1855a008f28e | 1473 | XMLComment* XMLDocument::NewComment( const char* str ) |
togayan | 0:1855a008f28e | 1474 | { |
togayan | 0:1855a008f28e | 1475 | XMLComment* comment = new (commentPool.Alloc()) XMLComment( this ); |
togayan | 0:1855a008f28e | 1476 | comment->memPool = &commentPool; |
togayan | 0:1855a008f28e | 1477 | comment->SetValue( str ); |
togayan | 0:1855a008f28e | 1478 | return comment; |
togayan | 0:1855a008f28e | 1479 | } |
togayan | 0:1855a008f28e | 1480 | |
togayan | 0:1855a008f28e | 1481 | |
togayan | 0:1855a008f28e | 1482 | XMLText* XMLDocument::NewText( const char* str ) |
togayan | 0:1855a008f28e | 1483 | { |
togayan | 0:1855a008f28e | 1484 | XMLText* text = new (textPool.Alloc()) XMLText( this ); |
togayan | 0:1855a008f28e | 1485 | text->memPool = &textPool; |
togayan | 0:1855a008f28e | 1486 | text->SetValue( str ); |
togayan | 0:1855a008f28e | 1487 | return text; |
togayan | 0:1855a008f28e | 1488 | } |
togayan | 0:1855a008f28e | 1489 | |
togayan | 0:1855a008f28e | 1490 | |
togayan | 0:1855a008f28e | 1491 | XMLDeclaration* XMLDocument::NewDeclaration( const char* str ) |
togayan | 0:1855a008f28e | 1492 | { |
togayan | 0:1855a008f28e | 1493 | XMLDeclaration* dec = new (commentPool.Alloc()) XMLDeclaration( this ); |
togayan | 0:1855a008f28e | 1494 | dec->memPool = &commentPool; |
togayan | 0:1855a008f28e | 1495 | dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" ); |
togayan | 0:1855a008f28e | 1496 | return dec; |
togayan | 0:1855a008f28e | 1497 | } |
togayan | 0:1855a008f28e | 1498 | |
togayan | 0:1855a008f28e | 1499 | |
togayan | 0:1855a008f28e | 1500 | XMLUnknown* XMLDocument::NewUnknown( const char* str ) |
togayan | 0:1855a008f28e | 1501 | { |
togayan | 0:1855a008f28e | 1502 | XMLUnknown* unk = new (commentPool.Alloc()) XMLUnknown( this ); |
togayan | 0:1855a008f28e | 1503 | unk->memPool = &commentPool; |
togayan | 0:1855a008f28e | 1504 | unk->SetValue( str ); |
togayan | 0:1855a008f28e | 1505 | return unk; |
togayan | 0:1855a008f28e | 1506 | } |
togayan | 0:1855a008f28e | 1507 | |
togayan | 0:1855a008f28e | 1508 | |
togayan | 0:1855a008f28e | 1509 | int XMLDocument::LoadFile( const char* filename ) |
togayan | 0:1855a008f28e | 1510 | { |
togayan | 0:1855a008f28e | 1511 | DeleteChildren(); |
togayan | 0:1855a008f28e | 1512 | InitDocument(); |
togayan | 0:1855a008f28e | 1513 | |
togayan | 0:1855a008f28e | 1514 | #if defined(_MSC_VER) |
togayan | 0:1855a008f28e | 1515 | #pragma warning ( push ) |
togayan | 0:1855a008f28e | 1516 | #pragma warning ( disable : 4996 ) // Fail to see a compelling reason why this should be deprecated. |
togayan | 0:1855a008f28e | 1517 | #endif |
togayan | 0:1855a008f28e | 1518 | FILE* fp = fopen( filename, "rb" ); |
togayan | 0:1855a008f28e | 1519 | #if defined(_MSC_VER) |
togayan | 0:1855a008f28e | 1520 | #pragma warning ( pop ) |
togayan | 0:1855a008f28e | 1521 | #endif |
togayan | 0:1855a008f28e | 1522 | if ( !fp ) { |
togayan | 0:1855a008f28e | 1523 | SetError( XML_ERROR_FILE_NOT_FOUND, filename, 0 ); |
togayan | 0:1855a008f28e | 1524 | return errorID; |
togayan | 0:1855a008f28e | 1525 | } |
togayan | 0:1855a008f28e | 1526 | LoadFile( fp ); |
togayan | 0:1855a008f28e | 1527 | fclose( fp ); |
togayan | 0:1855a008f28e | 1528 | return errorID; |
togayan | 0:1855a008f28e | 1529 | } |
togayan | 0:1855a008f28e | 1530 | |
togayan | 0:1855a008f28e | 1531 | |
togayan | 0:1855a008f28e | 1532 | int XMLDocument::LoadFile( FILE* fp ) |
togayan | 0:1855a008f28e | 1533 | { |
togayan | 0:1855a008f28e | 1534 | DeleteChildren(); |
togayan | 0:1855a008f28e | 1535 | InitDocument(); |
togayan | 0:1855a008f28e | 1536 | |
togayan | 0:1855a008f28e | 1537 | fseek( fp, 0, SEEK_END ); |
togayan | 0:1855a008f28e | 1538 | unsigned size = ftell( fp ); |
togayan | 0:1855a008f28e | 1539 | fseek( fp, 0, SEEK_SET ); |
togayan | 0:1855a008f28e | 1540 | |
togayan | 0:1855a008f28e | 1541 | if ( size == 0 ) { |
togayan | 0:1855a008f28e | 1542 | return errorID; |
togayan | 0:1855a008f28e | 1543 | } |
togayan | 0:1855a008f28e | 1544 | |
togayan | 0:1855a008f28e | 1545 | charBuffer = new char[size+1]; |
togayan | 0:1855a008f28e | 1546 | size_t read = fread( charBuffer, 1, size, fp ); |
togayan | 0:1855a008f28e | 1547 | if ( read != size ) { |
togayan | 0:1855a008f28e | 1548 | SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 ); |
togayan | 0:1855a008f28e | 1549 | return errorID; |
togayan | 0:1855a008f28e | 1550 | } |
togayan | 0:1855a008f28e | 1551 | |
togayan | 0:1855a008f28e | 1552 | charBuffer[size] = 0; |
togayan | 0:1855a008f28e | 1553 | |
togayan | 0:1855a008f28e | 1554 | const char* p = charBuffer; |
togayan | 0:1855a008f28e | 1555 | p = XMLUtil::SkipWhiteSpace( p ); |
togayan | 0:1855a008f28e | 1556 | p = XMLUtil::ReadBOM( p, &writeBOM ); |
togayan | 0:1855a008f28e | 1557 | if ( !p || !*p ) { |
togayan | 0:1855a008f28e | 1558 | SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 ); |
togayan | 0:1855a008f28e | 1559 | return errorID; |
togayan | 0:1855a008f28e | 1560 | } |
togayan | 0:1855a008f28e | 1561 | |
togayan | 0:1855a008f28e | 1562 | ParseDeep( charBuffer + (p-charBuffer), 0 ); |
togayan | 0:1855a008f28e | 1563 | return errorID; |
togayan | 0:1855a008f28e | 1564 | } |
togayan | 0:1855a008f28e | 1565 | |
togayan | 0:1855a008f28e | 1566 | |
togayan | 0:1855a008f28e | 1567 | int XMLDocument::SaveFile( const char* filename ) |
togayan | 0:1855a008f28e | 1568 | { |
togayan | 0:1855a008f28e | 1569 | #if defined(_MSC_VER) |
togayan | 0:1855a008f28e | 1570 | #pragma warning ( push ) |
togayan | 0:1855a008f28e | 1571 | #pragma warning ( disable : 4996 ) // Fail to see a compelling reason why this should be deprecated. |
togayan | 0:1855a008f28e | 1572 | #endif |
togayan | 0:1855a008f28e | 1573 | FILE* fp = fopen( filename, "w" ); |
togayan | 0:1855a008f28e | 1574 | #if defined(_MSC_VER) |
togayan | 0:1855a008f28e | 1575 | #pragma warning ( pop ) |
togayan | 0:1855a008f28e | 1576 | #endif |
togayan | 0:1855a008f28e | 1577 | if ( !fp ) { |
togayan | 0:1855a008f28e | 1578 | SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, filename, 0 ); |
togayan | 0:1855a008f28e | 1579 | return errorID; |
togayan | 0:1855a008f28e | 1580 | } |
togayan | 0:1855a008f28e | 1581 | SaveFile(fp); |
togayan | 0:1855a008f28e | 1582 | fclose( fp ); |
togayan | 0:1855a008f28e | 1583 | return errorID; |
togayan | 0:1855a008f28e | 1584 | } |
togayan | 0:1855a008f28e | 1585 | |
togayan | 0:1855a008f28e | 1586 | |
togayan | 0:1855a008f28e | 1587 | int XMLDocument::SaveFile( FILE* fp ) |
togayan | 0:1855a008f28e | 1588 | { |
togayan | 0:1855a008f28e | 1589 | XMLPrinter stream( fp ); |
togayan | 0:1855a008f28e | 1590 | Print( &stream ); |
togayan | 0:1855a008f28e | 1591 | return errorID; |
togayan | 0:1855a008f28e | 1592 | } |
togayan | 0:1855a008f28e | 1593 | |
togayan | 0:1855a008f28e | 1594 | |
togayan | 0:1855a008f28e | 1595 | int XMLDocument::Parse( const char* p ) |
togayan | 0:1855a008f28e | 1596 | { |
togayan | 0:1855a008f28e | 1597 | DeleteChildren(); |
togayan | 0:1855a008f28e | 1598 | InitDocument(); |
togayan | 0:1855a008f28e | 1599 | |
togayan | 0:1855a008f28e | 1600 | if ( !p || !*p ) { |
togayan | 0:1855a008f28e | 1601 | SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 ); |
togayan | 0:1855a008f28e | 1602 | return errorID; |
togayan | 0:1855a008f28e | 1603 | } |
togayan | 0:1855a008f28e | 1604 | p = XMLUtil::SkipWhiteSpace( p ); |
togayan | 0:1855a008f28e | 1605 | p = XMLUtil::ReadBOM( p, &writeBOM ); |
togayan | 0:1855a008f28e | 1606 | if ( !p || !*p ) { |
togayan | 0:1855a008f28e | 1607 | SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 ); |
togayan | 0:1855a008f28e | 1608 | return errorID; |
togayan | 0:1855a008f28e | 1609 | } |
togayan | 0:1855a008f28e | 1610 | |
togayan | 0:1855a008f28e | 1611 | size_t len = strlen( p ); |
togayan | 0:1855a008f28e | 1612 | charBuffer = new char[ len+1 ]; |
togayan | 0:1855a008f28e | 1613 | memcpy( charBuffer, p, len+1 ); |
togayan | 0:1855a008f28e | 1614 | |
togayan | 0:1855a008f28e | 1615 | |
togayan | 0:1855a008f28e | 1616 | ParseDeep( charBuffer, 0 ); |
togayan | 0:1855a008f28e | 1617 | return errorID; |
togayan | 0:1855a008f28e | 1618 | } |
togayan | 0:1855a008f28e | 1619 | |
togayan | 0:1855a008f28e | 1620 | |
togayan | 0:1855a008f28e | 1621 | void XMLDocument::Print( XMLPrinter* streamer ) |
togayan | 0:1855a008f28e | 1622 | { |
togayan | 0:1855a008f28e | 1623 | XMLPrinter stdStreamer( stdout ); |
togayan | 0:1855a008f28e | 1624 | if ( !streamer ) |
togayan | 0:1855a008f28e | 1625 | streamer = &stdStreamer; |
togayan | 0:1855a008f28e | 1626 | Accept( streamer ); |
togayan | 0:1855a008f28e | 1627 | } |
togayan | 0:1855a008f28e | 1628 | |
togayan | 0:1855a008f28e | 1629 | |
togayan | 0:1855a008f28e | 1630 | void XMLDocument::SetError( int error, const char* str1, const char* str2 ) |
togayan | 0:1855a008f28e | 1631 | { |
togayan | 0:1855a008f28e | 1632 | errorID = error; |
togayan | 0:1855a008f28e | 1633 | errorStr1 = str1; |
togayan | 0:1855a008f28e | 1634 | errorStr2 = str2; |
togayan | 0:1855a008f28e | 1635 | } |
togayan | 0:1855a008f28e | 1636 | |
togayan | 0:1855a008f28e | 1637 | |
togayan | 0:1855a008f28e | 1638 | void XMLDocument::PrintError() const |
togayan | 0:1855a008f28e | 1639 | { |
togayan | 0:1855a008f28e | 1640 | if ( errorID ) { |
togayan | 0:1855a008f28e | 1641 | static const int LEN = 20; |
togayan | 0:1855a008f28e | 1642 | char buf1[LEN] = { 0 }; |
togayan | 0:1855a008f28e | 1643 | char buf2[LEN] = { 0 }; |
togayan | 0:1855a008f28e | 1644 | |
togayan | 0:1855a008f28e | 1645 | if ( errorStr1 ) { |
togayan | 0:1855a008f28e | 1646 | TIXML_SNPRINTF( buf1, LEN, "%s", errorStr1 ); |
togayan | 0:1855a008f28e | 1647 | } |
togayan | 0:1855a008f28e | 1648 | if ( errorStr2 ) { |
togayan | 0:1855a008f28e | 1649 | TIXML_SNPRINTF( buf2, LEN, "%s", errorStr2 ); |
togayan | 0:1855a008f28e | 1650 | } |
togayan | 0:1855a008f28e | 1651 | |
togayan | 0:1855a008f28e | 1652 | printf( "XMLDocument error id=%d str1=%s str2=%s\n", |
togayan | 0:1855a008f28e | 1653 | errorID, buf1, buf2 ); |
togayan | 0:1855a008f28e | 1654 | } |
togayan | 0:1855a008f28e | 1655 | } |
togayan | 0:1855a008f28e | 1656 | |
togayan | 0:1855a008f28e | 1657 | |
togayan | 0:1855a008f28e | 1658 | XMLPrinter::XMLPrinter( FILE* file, bool compact ) : |
togayan | 0:1855a008f28e | 1659 | elementJustOpened( false ), |
togayan | 0:1855a008f28e | 1660 | firstElement( true ), |
togayan | 0:1855a008f28e | 1661 | fp( file ), |
togayan | 0:1855a008f28e | 1662 | depth( 0 ), |
togayan | 0:1855a008f28e | 1663 | textDepth( -1 ), |
togayan | 0:1855a008f28e | 1664 | processEntities( true ), |
togayan | 0:1855a008f28e | 1665 | compactMode( compact ) |
togayan | 0:1855a008f28e | 1666 | { |
togayan | 0:1855a008f28e | 1667 | for( int i=0; i<ENTITY_RANGE; ++i ) { |
togayan | 0:1855a008f28e | 1668 | entityFlag[i] = false; |
togayan | 0:1855a008f28e | 1669 | restrictedEntityFlag[i] = false; |
togayan | 0:1855a008f28e | 1670 | } |
togayan | 0:1855a008f28e | 1671 | for( int i=0; i<NUM_ENTITIES; ++i ) { |
togayan | 0:1855a008f28e | 1672 | TIXMLASSERT( entities[i].value < ENTITY_RANGE ); |
togayan | 0:1855a008f28e | 1673 | if ( entities[i].value < ENTITY_RANGE ) { |
togayan | 0:1855a008f28e | 1674 | entityFlag[ (int)entities[i].value ] = true; |
togayan | 0:1855a008f28e | 1675 | } |
togayan | 0:1855a008f28e | 1676 | } |
togayan | 0:1855a008f28e | 1677 | restrictedEntityFlag[(int)'&'] = true; |
togayan | 0:1855a008f28e | 1678 | restrictedEntityFlag[(int)'<'] = true; |
togayan | 0:1855a008f28e | 1679 | restrictedEntityFlag[(int)'>'] = true; // not required, but consistency is nice |
togayan | 0:1855a008f28e | 1680 | buffer.Push( 0 ); |
togayan | 0:1855a008f28e | 1681 | } |
togayan | 0:1855a008f28e | 1682 | |
togayan | 0:1855a008f28e | 1683 | |
togayan | 0:1855a008f28e | 1684 | void XMLPrinter::Print( const char* format, ... ) |
togayan | 0:1855a008f28e | 1685 | { |
togayan | 0:1855a008f28e | 1686 | va_list va; |
togayan | 0:1855a008f28e | 1687 | va_start( va, format ); |
togayan | 0:1855a008f28e | 1688 | |
togayan | 0:1855a008f28e | 1689 | if ( fp ) { |
togayan | 0:1855a008f28e | 1690 | vfprintf( fp, format, va ); |
togayan | 0:1855a008f28e | 1691 | } |
togayan | 0:1855a008f28e | 1692 | else { |
togayan | 0:1855a008f28e | 1693 | // This seems brutally complex. Haven't figured out a better |
togayan | 0:1855a008f28e | 1694 | // way on windows. |
togayan | 0:1855a008f28e | 1695 | #ifdef _MSC_VER |
togayan | 0:1855a008f28e | 1696 | int len = -1; |
togayan | 0:1855a008f28e | 1697 | int expand = 1000; |
togayan | 0:1855a008f28e | 1698 | while ( len < 0 ) { |
togayan | 0:1855a008f28e | 1699 | len = vsnprintf_s( accumulator.Mem(), accumulator.Capacity(), _TRUNCATE, format, va ); |
togayan | 0:1855a008f28e | 1700 | if ( len < 0 ) { |
togayan | 0:1855a008f28e | 1701 | expand *= 3/2; |
togayan | 0:1855a008f28e | 1702 | accumulator.PushArr( expand ); |
togayan | 0:1855a008f28e | 1703 | } |
togayan | 0:1855a008f28e | 1704 | } |
togayan | 0:1855a008f28e | 1705 | char* p = buffer.PushArr( len ) - 1; |
togayan | 0:1855a008f28e | 1706 | memcpy( p, accumulator.Mem(), len+1 ); |
togayan | 0:1855a008f28e | 1707 | #else |
togayan | 0:1855a008f28e | 1708 | int len = vsnprintf( 0, 0, format, va ); |
togayan | 0:1855a008f28e | 1709 | // Close out and re-start the va-args |
togayan | 0:1855a008f28e | 1710 | va_end( va ); |
togayan | 0:1855a008f28e | 1711 | va_start( va, format ); |
togayan | 0:1855a008f28e | 1712 | char* p = buffer.PushArr( len ) - 1; |
togayan | 0:1855a008f28e | 1713 | vsnprintf( p, len+1, format, va ); |
togayan | 0:1855a008f28e | 1714 | #endif |
togayan | 0:1855a008f28e | 1715 | } |
togayan | 0:1855a008f28e | 1716 | va_end( va ); |
togayan | 0:1855a008f28e | 1717 | } |
togayan | 0:1855a008f28e | 1718 | |
togayan | 0:1855a008f28e | 1719 | |
togayan | 0:1855a008f28e | 1720 | void XMLPrinter::PrintSpace( int depth ) |
togayan | 0:1855a008f28e | 1721 | { |
togayan | 0:1855a008f28e | 1722 | for( int i=0; i<depth; ++i ) { |
togayan | 0:1855a008f28e | 1723 | Print( " " ); |
togayan | 0:1855a008f28e | 1724 | } |
togayan | 0:1855a008f28e | 1725 | } |
togayan | 0:1855a008f28e | 1726 | |
togayan | 0:1855a008f28e | 1727 | |
togayan | 0:1855a008f28e | 1728 | void XMLPrinter::PrintString( const char* p, bool restricted ) |
togayan | 0:1855a008f28e | 1729 | { |
togayan | 0:1855a008f28e | 1730 | // Look for runs of bytes between entities to print. |
togayan | 0:1855a008f28e | 1731 | const char* q = p; |
togayan | 0:1855a008f28e | 1732 | const bool* flag = restricted ? restrictedEntityFlag : entityFlag; |
togayan | 0:1855a008f28e | 1733 | |
togayan | 0:1855a008f28e | 1734 | if ( processEntities ) { |
togayan | 0:1855a008f28e | 1735 | while ( *q ) { |
togayan | 0:1855a008f28e | 1736 | // Remember, char is sometimes signed. (How many times has that bitten me?) |
togayan | 0:1855a008f28e | 1737 | if ( *q > 0 && *q < ENTITY_RANGE ) { |
togayan | 0:1855a008f28e | 1738 | // Check for entities. If one is found, flush |
togayan | 0:1855a008f28e | 1739 | // the stream up until the entity, write the |
togayan | 0:1855a008f28e | 1740 | // entity, and keep looking. |
togayan | 0:1855a008f28e | 1741 | if ( flag[(unsigned)(*q)] ) { |
togayan | 0:1855a008f28e | 1742 | while ( p < q ) { |
togayan | 0:1855a008f28e | 1743 | Print( "%c", *p ); |
togayan | 0:1855a008f28e | 1744 | ++p; |
togayan | 0:1855a008f28e | 1745 | } |
togayan | 0:1855a008f28e | 1746 | for( int i=0; i<NUM_ENTITIES; ++i ) { |
togayan | 0:1855a008f28e | 1747 | if ( entities[i].value == *q ) { |
togayan | 0:1855a008f28e | 1748 | Print( "&%s;", entities[i].pattern ); |
togayan | 0:1855a008f28e | 1749 | break; |
togayan | 0:1855a008f28e | 1750 | } |
togayan | 0:1855a008f28e | 1751 | } |
togayan | 0:1855a008f28e | 1752 | ++p; |
togayan | 0:1855a008f28e | 1753 | } |
togayan | 0:1855a008f28e | 1754 | } |
togayan | 0:1855a008f28e | 1755 | ++q; |
togayan | 0:1855a008f28e | 1756 | } |
togayan | 0:1855a008f28e | 1757 | } |
togayan | 0:1855a008f28e | 1758 | // Flush the remaining string. This will be the entire |
togayan | 0:1855a008f28e | 1759 | // string if an entity wasn't found. |
togayan | 0:1855a008f28e | 1760 | if ( !processEntities || (q-p > 0) ) { |
togayan | 0:1855a008f28e | 1761 | Print( "%s", p ); |
togayan | 0:1855a008f28e | 1762 | } |
togayan | 0:1855a008f28e | 1763 | } |
togayan | 0:1855a008f28e | 1764 | |
togayan | 0:1855a008f28e | 1765 | |
togayan | 0:1855a008f28e | 1766 | void XMLPrinter::PushHeader( bool writeBOM, bool writeDec ) |
togayan | 0:1855a008f28e | 1767 | { |
togayan | 0:1855a008f28e | 1768 | static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 }; |
togayan | 0:1855a008f28e | 1769 | if ( writeBOM ) { |
togayan | 0:1855a008f28e | 1770 | Print( "%s", bom ); |
togayan | 0:1855a008f28e | 1771 | } |
togayan | 0:1855a008f28e | 1772 | if ( writeDec ) { |
togayan | 0:1855a008f28e | 1773 | PushDeclaration( "xml version=\"1.0\"" ); |
togayan | 0:1855a008f28e | 1774 | } |
togayan | 0:1855a008f28e | 1775 | } |
togayan | 0:1855a008f28e | 1776 | |
togayan | 0:1855a008f28e | 1777 | |
togayan | 0:1855a008f28e | 1778 | void XMLPrinter::OpenElement( const char* name ) |
togayan | 0:1855a008f28e | 1779 | { |
togayan | 0:1855a008f28e | 1780 | if ( elementJustOpened ) { |
togayan | 0:1855a008f28e | 1781 | SealElement(); |
togayan | 0:1855a008f28e | 1782 | } |
togayan | 0:1855a008f28e | 1783 | stack.Push( name ); |
togayan | 0:1855a008f28e | 1784 | |
togayan | 0:1855a008f28e | 1785 | if ( textDepth < 0 && !firstElement && !compactMode ) { |
togayan | 0:1855a008f28e | 1786 | Print( "\n" ); |
togayan | 0:1855a008f28e | 1787 | PrintSpace( depth ); |
togayan | 0:1855a008f28e | 1788 | } |
togayan | 0:1855a008f28e | 1789 | |
togayan | 0:1855a008f28e | 1790 | Print( "<%s", name ); |
togayan | 0:1855a008f28e | 1791 | elementJustOpened = true; |
togayan | 0:1855a008f28e | 1792 | firstElement = false; |
togayan | 0:1855a008f28e | 1793 | ++depth; |
togayan | 0:1855a008f28e | 1794 | } |
togayan | 0:1855a008f28e | 1795 | |
togayan | 0:1855a008f28e | 1796 | |
togayan | 0:1855a008f28e | 1797 | void XMLPrinter::PushAttribute( const char* name, const char* value ) |
togayan | 0:1855a008f28e | 1798 | { |
togayan | 0:1855a008f28e | 1799 | TIXMLASSERT( elementJustOpened ); |
togayan | 0:1855a008f28e | 1800 | Print( " %s=\"", name ); |
togayan | 0:1855a008f28e | 1801 | PrintString( value, false ); |
togayan | 0:1855a008f28e | 1802 | Print( "\"" ); |
togayan | 0:1855a008f28e | 1803 | } |
togayan | 0:1855a008f28e | 1804 | |
togayan | 0:1855a008f28e | 1805 | |
togayan | 0:1855a008f28e | 1806 | void XMLPrinter::PushAttribute( const char* name, int v ) |
togayan | 0:1855a008f28e | 1807 | { |
togayan | 0:1855a008f28e | 1808 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1809 | XMLUtil::ToStr( v, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1810 | PushAttribute( name, buf ); |
togayan | 0:1855a008f28e | 1811 | } |
togayan | 0:1855a008f28e | 1812 | |
togayan | 0:1855a008f28e | 1813 | |
togayan | 0:1855a008f28e | 1814 | void XMLPrinter::PushAttribute( const char* name, unsigned v ) |
togayan | 0:1855a008f28e | 1815 | { |
togayan | 0:1855a008f28e | 1816 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1817 | XMLUtil::ToStr( v, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1818 | PushAttribute( name, buf ); |
togayan | 0:1855a008f28e | 1819 | } |
togayan | 0:1855a008f28e | 1820 | |
togayan | 0:1855a008f28e | 1821 | |
togayan | 0:1855a008f28e | 1822 | void XMLPrinter::PushAttribute( const char* name, bool v ) |
togayan | 0:1855a008f28e | 1823 | { |
togayan | 0:1855a008f28e | 1824 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1825 | XMLUtil::ToStr( v, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1826 | PushAttribute( name, buf ); |
togayan | 0:1855a008f28e | 1827 | } |
togayan | 0:1855a008f28e | 1828 | |
togayan | 0:1855a008f28e | 1829 | |
togayan | 0:1855a008f28e | 1830 | void XMLPrinter::PushAttribute( const char* name, double v ) |
togayan | 0:1855a008f28e | 1831 | { |
togayan | 0:1855a008f28e | 1832 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1833 | XMLUtil::ToStr( v, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1834 | PushAttribute( name, buf ); |
togayan | 0:1855a008f28e | 1835 | } |
togayan | 0:1855a008f28e | 1836 | |
togayan | 0:1855a008f28e | 1837 | |
togayan | 0:1855a008f28e | 1838 | void XMLPrinter::CloseElement() |
togayan | 0:1855a008f28e | 1839 | { |
togayan | 0:1855a008f28e | 1840 | --depth; |
togayan | 0:1855a008f28e | 1841 | const char* name = stack.Pop(); |
togayan | 0:1855a008f28e | 1842 | |
togayan | 0:1855a008f28e | 1843 | if ( elementJustOpened ) { |
togayan | 0:1855a008f28e | 1844 | Print( "/>" ); |
togayan | 0:1855a008f28e | 1845 | } |
togayan | 0:1855a008f28e | 1846 | else { |
togayan | 0:1855a008f28e | 1847 | if ( textDepth < 0 && !compactMode) { |
togayan | 0:1855a008f28e | 1848 | Print( "\n" ); |
togayan | 0:1855a008f28e | 1849 | PrintSpace( depth ); |
togayan | 0:1855a008f28e | 1850 | } |
togayan | 0:1855a008f28e | 1851 | Print( "</%s>", name ); |
togayan | 0:1855a008f28e | 1852 | } |
togayan | 0:1855a008f28e | 1853 | |
togayan | 0:1855a008f28e | 1854 | if ( textDepth == depth ) |
togayan | 0:1855a008f28e | 1855 | textDepth = -1; |
togayan | 0:1855a008f28e | 1856 | if ( depth == 0 && !compactMode) |
togayan | 0:1855a008f28e | 1857 | Print( "\n" ); |
togayan | 0:1855a008f28e | 1858 | elementJustOpened = false; |
togayan | 0:1855a008f28e | 1859 | } |
togayan | 0:1855a008f28e | 1860 | |
togayan | 0:1855a008f28e | 1861 | |
togayan | 0:1855a008f28e | 1862 | void XMLPrinter::SealElement() |
togayan | 0:1855a008f28e | 1863 | { |
togayan | 0:1855a008f28e | 1864 | elementJustOpened = false; |
togayan | 0:1855a008f28e | 1865 | Print( ">" ); |
togayan | 0:1855a008f28e | 1866 | } |
togayan | 0:1855a008f28e | 1867 | |
togayan | 0:1855a008f28e | 1868 | |
togayan | 0:1855a008f28e | 1869 | void XMLPrinter::PushText( const char* text, bool cdata ) |
togayan | 0:1855a008f28e | 1870 | { |
togayan | 0:1855a008f28e | 1871 | textDepth = depth-1; |
togayan | 0:1855a008f28e | 1872 | |
togayan | 0:1855a008f28e | 1873 | if ( elementJustOpened ) { |
togayan | 0:1855a008f28e | 1874 | SealElement(); |
togayan | 0:1855a008f28e | 1875 | } |
togayan | 0:1855a008f28e | 1876 | if ( cdata ) { |
togayan | 0:1855a008f28e | 1877 | Print( "<![CDATA[" ); |
togayan | 0:1855a008f28e | 1878 | Print( "%s", text ); |
togayan | 0:1855a008f28e | 1879 | Print( "]]>" ); |
togayan | 0:1855a008f28e | 1880 | } |
togayan | 0:1855a008f28e | 1881 | else { |
togayan | 0:1855a008f28e | 1882 | PrintString( text, true ); |
togayan | 0:1855a008f28e | 1883 | } |
togayan | 0:1855a008f28e | 1884 | } |
togayan | 0:1855a008f28e | 1885 | |
togayan | 0:1855a008f28e | 1886 | void XMLPrinter::PushText( int value ) |
togayan | 0:1855a008f28e | 1887 | { |
togayan | 0:1855a008f28e | 1888 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1889 | XMLUtil::ToStr( value, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1890 | PushText( buf, false ); |
togayan | 0:1855a008f28e | 1891 | } |
togayan | 0:1855a008f28e | 1892 | |
togayan | 0:1855a008f28e | 1893 | |
togayan | 0:1855a008f28e | 1894 | void XMLPrinter::PushText( unsigned value ) |
togayan | 0:1855a008f28e | 1895 | { |
togayan | 0:1855a008f28e | 1896 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1897 | XMLUtil::ToStr( value, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1898 | PushText( buf, false ); |
togayan | 0:1855a008f28e | 1899 | } |
togayan | 0:1855a008f28e | 1900 | |
togayan | 0:1855a008f28e | 1901 | |
togayan | 0:1855a008f28e | 1902 | void XMLPrinter::PushText( bool value ) |
togayan | 0:1855a008f28e | 1903 | { |
togayan | 0:1855a008f28e | 1904 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1905 | XMLUtil::ToStr( value, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1906 | PushText( buf, false ); |
togayan | 0:1855a008f28e | 1907 | } |
togayan | 0:1855a008f28e | 1908 | |
togayan | 0:1855a008f28e | 1909 | |
togayan | 0:1855a008f28e | 1910 | void XMLPrinter::PushText( float value ) |
togayan | 0:1855a008f28e | 1911 | { |
togayan | 0:1855a008f28e | 1912 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1913 | XMLUtil::ToStr( value, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1914 | PushText( buf, false ); |
togayan | 0:1855a008f28e | 1915 | } |
togayan | 0:1855a008f28e | 1916 | |
togayan | 0:1855a008f28e | 1917 | |
togayan | 0:1855a008f28e | 1918 | void XMLPrinter::PushText( double value ) |
togayan | 0:1855a008f28e | 1919 | { |
togayan | 0:1855a008f28e | 1920 | char buf[BUF_SIZE]; |
togayan | 0:1855a008f28e | 1921 | XMLUtil::ToStr( value, buf, BUF_SIZE ); |
togayan | 0:1855a008f28e | 1922 | PushText( buf, false ); |
togayan | 0:1855a008f28e | 1923 | } |
togayan | 0:1855a008f28e | 1924 | |
togayan | 0:1855a008f28e | 1925 | |
togayan | 0:1855a008f28e | 1926 | void XMLPrinter::PushComment( const char* comment ) |
togayan | 0:1855a008f28e | 1927 | { |
togayan | 0:1855a008f28e | 1928 | if ( elementJustOpened ) { |
togayan | 0:1855a008f28e | 1929 | SealElement(); |
togayan | 0:1855a008f28e | 1930 | } |
togayan | 0:1855a008f28e | 1931 | if ( textDepth < 0 && !firstElement && !compactMode) { |
togayan | 0:1855a008f28e | 1932 | Print( "\n" ); |
togayan | 0:1855a008f28e | 1933 | PrintSpace( depth ); |
togayan | 0:1855a008f28e | 1934 | } |
togayan | 0:1855a008f28e | 1935 | firstElement = false; |
togayan | 0:1855a008f28e | 1936 | Print( "<!--%s-->", comment ); |
togayan | 0:1855a008f28e | 1937 | } |
togayan | 0:1855a008f28e | 1938 | |
togayan | 0:1855a008f28e | 1939 | |
togayan | 0:1855a008f28e | 1940 | void XMLPrinter::PushDeclaration( const char* value ) |
togayan | 0:1855a008f28e | 1941 | { |
togayan | 0:1855a008f28e | 1942 | if ( elementJustOpened ) { |
togayan | 0:1855a008f28e | 1943 | SealElement(); |
togayan | 0:1855a008f28e | 1944 | } |
togayan | 0:1855a008f28e | 1945 | if ( textDepth < 0 && !firstElement && !compactMode) { |
togayan | 0:1855a008f28e | 1946 | Print( "\n" ); |
togayan | 0:1855a008f28e | 1947 | PrintSpace( depth ); |
togayan | 0:1855a008f28e | 1948 | } |
togayan | 0:1855a008f28e | 1949 | firstElement = false; |
togayan | 0:1855a008f28e | 1950 | Print( "<?%s?>", value ); |
togayan | 0:1855a008f28e | 1951 | } |
togayan | 0:1855a008f28e | 1952 | |
togayan | 0:1855a008f28e | 1953 | |
togayan | 0:1855a008f28e | 1954 | void XMLPrinter::PushUnknown( const char* value ) |
togayan | 0:1855a008f28e | 1955 | { |
togayan | 0:1855a008f28e | 1956 | if ( elementJustOpened ) { |
togayan | 0:1855a008f28e | 1957 | SealElement(); |
togayan | 0:1855a008f28e | 1958 | } |
togayan | 0:1855a008f28e | 1959 | if ( textDepth < 0 && !firstElement && !compactMode) { |
togayan | 0:1855a008f28e | 1960 | Print( "\n" ); |
togayan | 0:1855a008f28e | 1961 | PrintSpace( depth ); |
togayan | 0:1855a008f28e | 1962 | } |
togayan | 0:1855a008f28e | 1963 | firstElement = false; |
togayan | 0:1855a008f28e | 1964 | Print( "<!%s>", value ); |
togayan | 0:1855a008f28e | 1965 | } |
togayan | 0:1855a008f28e | 1966 | |
togayan | 0:1855a008f28e | 1967 | |
togayan | 0:1855a008f28e | 1968 | bool XMLPrinter::VisitEnter( const XMLDocument& doc ) |
togayan | 0:1855a008f28e | 1969 | { |
togayan | 0:1855a008f28e | 1970 | processEntities = doc.ProcessEntities(); |
togayan | 0:1855a008f28e | 1971 | if ( doc.HasBOM() ) { |
togayan | 0:1855a008f28e | 1972 | PushHeader( true, false ); |
togayan | 0:1855a008f28e | 1973 | } |
togayan | 0:1855a008f28e | 1974 | return true; |
togayan | 0:1855a008f28e | 1975 | } |
togayan | 0:1855a008f28e | 1976 | |
togayan | 0:1855a008f28e | 1977 | |
togayan | 0:1855a008f28e | 1978 | bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute ) |
togayan | 0:1855a008f28e | 1979 | { |
togayan | 0:1855a008f28e | 1980 | OpenElement( element.Name() ); |
togayan | 0:1855a008f28e | 1981 | while ( attribute ) { |
togayan | 0:1855a008f28e | 1982 | PushAttribute( attribute->Name(), attribute->Value() ); |
togayan | 0:1855a008f28e | 1983 | attribute = attribute->Next(); |
togayan | 0:1855a008f28e | 1984 | } |
togayan | 0:1855a008f28e | 1985 | return true; |
togayan | 0:1855a008f28e | 1986 | } |
togayan | 0:1855a008f28e | 1987 | |
togayan | 0:1855a008f28e | 1988 | |
togayan | 0:1855a008f28e | 1989 | bool XMLPrinter::VisitExit( const XMLElement& ) |
togayan | 0:1855a008f28e | 1990 | { |
togayan | 0:1855a008f28e | 1991 | CloseElement(); |
togayan | 0:1855a008f28e | 1992 | return true; |
togayan | 0:1855a008f28e | 1993 | } |
togayan | 0:1855a008f28e | 1994 | |
togayan | 0:1855a008f28e | 1995 | |
togayan | 0:1855a008f28e | 1996 | bool XMLPrinter::Visit( const XMLText& text ) |
togayan | 0:1855a008f28e | 1997 | { |
togayan | 0:1855a008f28e | 1998 | PushText( text.Value(), text.CData() ); |
togayan | 0:1855a008f28e | 1999 | return true; |
togayan | 0:1855a008f28e | 2000 | } |
togayan | 0:1855a008f28e | 2001 | |
togayan | 0:1855a008f28e | 2002 | |
togayan | 0:1855a008f28e | 2003 | bool XMLPrinter::Visit( const XMLComment& comment ) |
togayan | 0:1855a008f28e | 2004 | { |
togayan | 0:1855a008f28e | 2005 | PushComment( comment.Value() ); |
togayan | 0:1855a008f28e | 2006 | return true; |
togayan | 0:1855a008f28e | 2007 | } |
togayan | 0:1855a008f28e | 2008 | |
togayan | 0:1855a008f28e | 2009 | bool XMLPrinter::Visit( const XMLDeclaration& declaration ) |
togayan | 0:1855a008f28e | 2010 | { |
togayan | 0:1855a008f28e | 2011 | PushDeclaration( declaration.Value() ); |
togayan | 0:1855a008f28e | 2012 | return true; |
togayan | 0:1855a008f28e | 2013 | } |
togayan | 0:1855a008f28e | 2014 | |
togayan | 0:1855a008f28e | 2015 | |
togayan | 0:1855a008f28e | 2016 | bool XMLPrinter::Visit( const XMLUnknown& unknown ) |
togayan | 0:1855a008f28e | 2017 | { |
togayan | 0:1855a008f28e | 2018 | PushUnknown( unknown.Value() ); |
togayan | 0:1855a008f28e | 2019 | return true; |
togayan | 0:1855a008f28e | 2020 | } |