1/* 2www.sourceforge.net/projects/tinyxml 3Original code by Lee Thomason (www.grinninglizard.com) 4 5This software is provided 'as-is', without any express or implied 6warranty. In no event will the authors be held liable for any 7damages arising from the use of this software. 8 9Permission is granted to anyone to use this software for any 10purpose, including commercial applications, and to alter it and 11redistribute it freely, subject to the following restrictions: 12 131. The origin of this software must not be misrepresented; you must 14not claim that you wrote the original software. If you use this 15software in a product, an acknowledgment in the product documentation 16would be appreciated but is not required. 17 182. Altered source versions must be plainly marked as such, and 19must not be misrepresented as being the original software. 20 213. This notice may not be removed or altered from any source 22distribution. 23*/ 24 25#include <ctype.h> 26#include <stddef.h> 27 28#include "tinyxml.h" 29 30//#define DEBUG_PARSER 31#if defined( DEBUG_PARSER ) 32# if defined( DEBUG ) && defined( _MSC_VER ) 33# include <windows.h> 34# define TIXML_LOG OutputDebugString 35# else 36# define TIXML_LOG printf 37# endif 38#endif 39 40// Note tha "PutString" hardcodes the same list. This 41// is less flexible than it appears. Changing the entries 42// or order will break putstring. 43TiXmlBase::Entity TiXmlBase::entity[ TiXmlBase::NUM_ENTITY ] = 44{ 45 { "&", 5, '&' }, 46 { "<", 4, '<' }, 47 { ">", 4, '>' }, 48 { """, 6, '\"' }, 49 { "'", 6, '\'' } 50}; 51 52// Bunch of unicode info at: 53// http://www.unicode.org/faq/utf_bom.html 54// Including the basic of this table, which determines the #bytes in the 55// sequence from the lead byte. 1 placed for invalid sequences -- 56// although the result will be junk, pass it through as much as possible. 57// Beware of the non-characters in UTF-8: 58// ef bb bf (Microsoft "lead bytes") 59// ef bf be 60// ef bf bf 61 62const unsigned char TIXML_UTF_LEAD_0 = 0xefU; 63const unsigned char TIXML_UTF_LEAD_1 = 0xbbU; 64const unsigned char TIXML_UTF_LEAD_2 = 0xbfU; 65 66const int TiXmlBase::utf8ByteTable[256] = 67{ 68 // 0 1 2 3 4 5 6 7 8 9 a b c d e f 69 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x00 70 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x10 71 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x20 72 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x30 73 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 74 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x50 75 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 76 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x70 End of ASCII range 77 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x80 0x80 to 0xc1 invalid 78 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x90 79 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xa0 80 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0xb0 81 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xc0 0xc2 to 0xdf 2 byte 82 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xd0 83 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xe0 0xe0 to 0xef 3 byte 84 4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid 85}; 86 87 88void TiXmlBase::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length ) 89{ 90 const unsigned long BYTE_MASK = 0xBF; 91 const unsigned long BYTE_MARK = 0x80; 92 const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; 93 94 if (input < 0x80) 95 *length = 1; 96 else if ( input < 0x800 ) 97 *length = 2; 98 else if ( input < 0x10000 ) 99 *length = 3; 100 else if ( input < 0x200000 ) 101 *length = 4; 102 else 103 { *length = 0; return; } // This code won't covert this correctly anyway. 104 105 output += *length; 106 107 // Scary scary fall throughs. 108 switch (*length) 109 { 110 case 4: 111 --output; 112 *output = (char)((input | BYTE_MARK) & BYTE_MASK); 113 input >>= 6; 114 case 3: 115 --output; 116 *output = (char)((input | BYTE_MARK) & BYTE_MASK); 117 input >>= 6; 118 case 2: 119 --output; 120 *output = (char)((input | BYTE_MARK) & BYTE_MASK); 121 input >>= 6; 122 case 1: 123 --output; 124 *output = (char)(input | FIRST_BYTE_MARK[*length]); 125 } 126} 127 128 129/*static*/ int TiXmlBase::IsAlpha( unsigned char anyByte, TiXmlEncoding /*encoding*/ ) 130{ 131 // This will only work for low-ascii, everything else is assumed to be a valid 132 // letter. I'm not sure this is the best approach, but it is quite tricky trying 133 // to figure out alhabetical vs. not across encoding. So take a very 134 // conservative approach. 135 136// if ( encoding == TIXML_ENCODING_UTF8 ) 137// { 138 if ( anyByte < 127 ) 139 return isalpha( anyByte ); 140 else 141 return 1; // What else to do? The unicode set is huge...get the english ones right. 142// } 143// else 144// { 145// return isalpha( anyByte ); 146// } 147} 148 149 150/*static*/ int TiXmlBase::IsAlphaNum( unsigned char anyByte, TiXmlEncoding /*encoding*/ ) 151{ 152 // This will only work for low-ascii, everything else is assumed to be a valid 153 // letter. I'm not sure this is the best approach, but it is quite tricky trying 154 // to figure out alhabetical vs. not across encoding. So take a very 155 // conservative approach. 156 157// if ( encoding == TIXML_ENCODING_UTF8 ) 158// { 159 if ( anyByte < 127 ) 160 return isalnum( anyByte ); 161 else 162 return 1; // What else to do? The unicode set is huge...get the english ones right. 163// } 164// else 165// { 166// return isalnum( anyByte ); 167// } 168} 169 170 171class TiXmlParsingData 172{ 173 friend class TiXmlDocument; 174 public: 175 void Stamp( const char* now, TiXmlEncoding encoding ); 176 177 const TiXmlCursor& Cursor() const { return cursor; } 178 179 private: 180 // Only used by the document! 181 TiXmlParsingData( const char* start, int _tabsize, int row, int col ) 182 { 183 assert( start ); 184 stamp = start; 185 tabsize = _tabsize; 186 cursor.row = row; 187 cursor.col = col; 188 } 189 190 TiXmlCursor cursor; 191 const char* stamp; 192 int tabsize; 193}; 194 195 196void TiXmlParsingData::Stamp( const char* now, TiXmlEncoding encoding ) 197{ 198 assert( now ); 199 200 // Do nothing if the tabsize is 0. 201 if ( tabsize < 1 ) 202 { 203 return; 204 } 205 206 // Get the current row, column. 207 int row = cursor.row; 208 int col = cursor.col; 209 const char* p = stamp; 210 assert( p ); 211 212 while ( p < now ) 213 { 214 // Treat p as unsigned, so we have a happy compiler. 215 const unsigned char* pU = (const unsigned char*)p; 216 217 // Code contributed by Fletcher Dunn: (modified by lee) 218 switch (*pU) { 219 case 0: 220 // We *should* never get here, but in case we do, don't 221 // advance past the terminating null character, ever 222 return; 223 224 case '\r': 225 // bump down to the next line 226 ++row; 227 col = 0; 228 // Eat the character 229 ++p; 230 231 // Check for \r\n sequence, and treat this as a single character 232 if (*p == '\n') { 233 ++p; 234 } 235 break; 236 237 case '\n': 238 // bump down to the next line 239 ++row; 240 col = 0; 241 242 // Eat the character 243 ++p; 244 245 // Check for \n\r sequence, and treat this as a single 246 // character. (Yes, this bizarre thing does occur still 247 // on some arcane platforms...) 248 if (*p == '\r') { 249 ++p; 250 } 251 break; 252 253 case '\t': 254 // Eat the character 255 ++p; 256 257 // Skip to next tab stop 258 col = (col / tabsize + 1) * tabsize; 259 break; 260 261 case TIXML_UTF_LEAD_0: 262 if ( encoding == TIXML_ENCODING_UTF8 ) 263 { 264 if ( *(p+1) && *(p+2) ) 265 { 266 // In these cases, don't advance the column. These are 267 // 0-width spaces. 268 if ( *(pU+1)==TIXML_UTF_LEAD_1 && *(pU+2)==TIXML_UTF_LEAD_2 ) 269 p += 3; 270 else if ( *(pU+1)==0xbfU && *(pU+2)==0xbeU ) 271 p += 3; 272 else if ( *(pU+1)==0xbfU && *(pU+2)==0xbfU ) 273 p += 3; 274 else 275 { p +=3; ++col; } // A normal character. 276 } 277 } 278 else 279 { 280 ++p; 281 ++col; 282 } 283 break; 284 285 default: 286 if ( encoding == TIXML_ENCODING_UTF8 ) 287 { 288 // Eat the 1 to 4 byte utf8 character. 289 int step = TiXmlBase::utf8ByteTable[*((const unsigned char*)p)]; 290 if ( step == 0 ) 291 step = 1; // Error case from bad encoding, but handle gracefully. 292 p += step; 293 294 // Just advance one column, of course. 295 ++col; 296 } 297 else 298 { 299 ++p; 300 ++col; 301 } 302 break; 303 } 304 } 305 cursor.row = row; 306 cursor.col = col; 307 assert( cursor.row >= -1 ); 308 assert( cursor.col >= -1 ); 309 stamp = p; 310 assert( stamp ); 311} 312 313 314const char* TiXmlBase::SkipWhiteSpace( const char* p, TiXmlEncoding encoding ) 315{ 316 if ( !p || !*p ) 317 { 318 return 0; 319 } 320 if ( encoding == TIXML_ENCODING_UTF8 ) 321 { 322 while ( *p ) 323 { 324 const unsigned char* pU = (const unsigned char*)p; 325 326 // Skip the stupid Microsoft UTF-8 Byte order marks 327 if ( *(pU+0)==TIXML_UTF_LEAD_0 328 && *(pU+1)==TIXML_UTF_LEAD_1 329 && *(pU+2)==TIXML_UTF_LEAD_2 ) 330 { 331 p += 3; 332 continue; 333 } 334 else if(*(pU+0)==TIXML_UTF_LEAD_0 335 && *(pU+1)==0xbfU 336 && *(pU+2)==0xbeU ) 337 { 338 p += 3; 339 continue; 340 } 341 else if(*(pU+0)==TIXML_UTF_LEAD_0 342 && *(pU+1)==0xbfU 343 && *(pU+2)==0xbfU ) 344 { 345 p += 3; 346 continue; 347 } 348 349 if ( IsWhiteSpace( *p ) ) // Still using old rules for white space. 350 ++p; 351 else 352 break; 353 } 354 } 355 else 356 { 357 while ( *p && IsWhiteSpace( *p ) ) 358 ++p; 359 } 360 361 return p; 362} 363 364#ifdef TIXML_USE_STL 365/*static*/ bool TiXmlBase::StreamWhiteSpace( std::istream * in, TIXML_STRING * tag ) 366{ 367 for( ;; ) 368 { 369 if ( !in->good() ) return false; 370 371 int c = in->peek(); 372 // At this scope, we can't get to a document. So fail silently. 373 if ( !IsWhiteSpace( c ) || c <= 0 ) 374 return true; 375 376 *tag += (char) in->get(); 377 } 378} 379 380/*static*/ bool TiXmlBase::StreamTo( std::istream * in, int character, TIXML_STRING * tag ) 381{ 382 //assert( character > 0 && character < 128 ); // else it won't work in utf-8 383 while ( in->good() ) 384 { 385 int c = in->peek(); 386 if ( c == character ) 387 return true; 388 if ( c <= 0 ) // Silent failure: can't get document at this scope 389 return false; 390 391 in->get(); 392 *tag += (char) c; 393 } 394 return false; 395} 396#endif 397 398// One of TinyXML's more performance demanding functions. Try to keep the memory overhead down. The 399// "assign" optimization removes over 10% of the execution time. 400// 401const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncoding encoding ) 402{ 403 // Oddly, not supported on some comilers, 404 //name->clear(); 405 // So use this: 406 *name = ""; 407 assert( p ); 408 409 // Names start with letters or underscores. 410 // Of course, in unicode, tinyxml has no idea what a letter *is*. The 411 // algorithm is generous. 412 // 413 // After that, they can be letters, underscores, numbers, 414 // hyphens, or colons. (Colons are valid ony for namespaces, 415 // but tinyxml can't tell namespaces from names.) 416 if ( p && *p 417 && ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) ) 418 { 419 const char* start = p; 420 while( p && *p 421 && ( IsAlphaNum( (unsigned char ) *p, encoding ) 422 || *p == '_' 423 || *p == '-' 424 || *p == '.' 425 || *p == ':' ) ) 426 { 427 //(*name) += *p; // expensive 428 ++p; 429 } 430 if ( p-start > 0 ) { 431 name->assign( start, p-start ); 432 } 433 return p; 434 } 435 return 0; 436} 437 438const char* TiXmlBase::GetEntity( const char* p, char* value, int* length, TiXmlEncoding encoding ) 439{ 440 // Presume an entity, and pull it out. 441 TIXML_STRING ent; 442 int i; 443 *length = 0; 444 445 if ( *(p+1) && *(p+1) == '#' && *(p+2) ) 446 { 447 unsigned long ucs = 0; 448 ptrdiff_t delta = 0; 449 unsigned mult = 1; 450 451 if ( *(p+2) == 'x' ) 452 { 453 // Hexadecimal. 454 if ( !*(p+3) ) return 0; 455 456 const char* q = p+3; 457 q = strchr( q, ';' ); 458 459 if ( !q || !*q ) return 0; 460 461 delta = q-p; 462 --q; 463 464 while ( *q != 'x' ) 465 { 466 if ( *q >= '0' && *q <= '9' ) 467 ucs += mult * (*q - '0'); 468 else if ( *q >= 'a' && *q <= 'f' ) 469 ucs += mult * (*q - 'a' + 10); 470 else if ( *q >= 'A' && *q <= 'F' ) 471 ucs += mult * (*q - 'A' + 10 ); 472 else 473 return 0; 474 mult *= 16; 475 --q; 476 } 477 } 478 else 479 { 480 // Decimal. 481 if ( !*(p+2) ) return 0; 482 483 const char* q = p+2; 484 q = strchr( q, ';' ); 485 486 if ( !q || !*q ) return 0; 487 488 delta = q-p; 489 --q; 490 491 while ( *q != '#' ) 492 { 493 if ( *q >= '0' && *q <= '9' ) 494 ucs += mult * (*q - '0'); 495 else 496 return 0; 497 mult *= 10; 498 --q; 499 } 500 } 501 if ( encoding == TIXML_ENCODING_UTF8 ) 502 { 503 // convert the UCS to UTF-8 504 ConvertUTF32ToUTF8( ucs, value, length ); 505 } 506 else 507 { 508 *value = (char)ucs; 509 *length = 1; 510 } 511 return p + delta + 1; 512 } 513 514 // Now try to match it. 515 for( i=0; i<NUM_ENTITY; ++i ) 516 { 517 if ( strncmp( entity[i].str, p, entity[i].strLength ) == 0 ) 518 { 519 assert( strlen( entity[i].str ) == entity[i].strLength ); 520 *value = entity[i].chr; 521 *length = 1; 522 return ( p + entity[i].strLength ); 523 } 524 } 525 526 // So it wasn't an entity, its unrecognized, or something like that. 527 *value = *p; // Don't put back the last one, since we return it! 528 //*length = 1; // Leave unrecognized entities - this doesn't really work. 529 // Just writes strange XML. 530 return p+1; 531} 532 533 534bool TiXmlBase::StringEqual( const char* p, 535 const char* tag, 536 bool ignoreCase, 537 TiXmlEncoding encoding ) 538{ 539 assert( p ); 540 assert( tag ); 541 if ( !p || !*p ) 542 { 543 assert( 0 ); 544 return false; 545 } 546 547 const char* q = p; 548 549 if ( ignoreCase ) 550 { 551 while ( *q && *tag && ToLower( *q, encoding ) == ToLower( *tag, encoding ) ) 552 { 553 ++q; 554 ++tag; 555 } 556 557 if ( *tag == 0 ) 558 return true; 559 } 560 else 561 { 562 while ( *q && *tag && *q == *tag ) 563 { 564 ++q; 565 ++tag; 566 } 567 568 if ( *tag == 0 ) // Have we found the end of the tag, and everything equal? 569 return true; 570 } 571 return false; 572} 573 574const char* TiXmlBase::ReadText( const char* p, 575 TIXML_STRING * text, 576 bool trimWhiteSpace, 577 const char* endTag, 578 bool caseInsensitive, 579 TiXmlEncoding encoding ) 580{ 581 *text = ""; 582 if ( !trimWhiteSpace // certain tags always keep whitespace 583 || !condenseWhiteSpace ) // if true, whitespace is always kept 584 { 585 // Keep all the white space. 586 while ( p && *p 587 && !StringEqual( p, endTag, caseInsensitive, encoding ) 588 ) 589 { 590 int len; 591 char cArr[4] = { 0, 0, 0, 0 }; 592 p = GetChar( p, cArr, &len, encoding ); 593 text->append( cArr, len ); 594 } 595 } 596 else 597 { 598 bool whitespace = false; 599 600 // Remove leading white space: 601 p = SkipWhiteSpace( p, encoding ); 602 while ( p && *p 603 && !StringEqual( p, endTag, caseInsensitive, encoding ) ) 604 { 605 if ( *p == '\r' || *p == '\n' ) 606 { 607 whitespace = true; 608 ++p; 609 } 610 else if ( IsWhiteSpace( *p ) ) 611 { 612 whitespace = true; 613 ++p; 614 } 615 else 616 { 617 // If we've found whitespace, add it before the 618 // new character. Any whitespace just becomes a space. 619 if ( whitespace ) 620 { 621 (*text) += ' '; 622 whitespace = false; 623 } 624 int len; 625 char cArr[4] = { 0, 0, 0, 0 }; 626 p = GetChar( p, cArr, &len, encoding ); 627 if ( len == 1 ) 628 (*text) += cArr[0]; // more efficient 629 else 630 text->append( cArr, len ); 631 } 632 } 633 } 634 if ( p && *p ) 635 p += strlen( endTag ); 636 return ( p && *p ) ? p : 0; 637} 638 639#ifdef TIXML_USE_STL 640 641void TiXmlDocument::StreamIn( std::istream * in, TIXML_STRING * tag ) 642{ 643 // The basic issue with a document is that we don't know what we're 644 // streaming. Read something presumed to be a tag (and hope), then 645 // identify it, and call the appropriate stream method on the tag. 646 // 647 // This "pre-streaming" will never read the closing ">" so the 648 // sub-tag can orient itself. 649 650 if ( !StreamTo( in, '<', tag ) ) 651 { 652 SetError( TIXML_ERROR_PARSING_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); 653 return; 654 } 655 656 while ( in->good() ) 657 { 658 int tagIndex = (int) tag->length(); 659 while ( in->good() && in->peek() != '>' ) 660 { 661 int c = in->get(); 662 if ( c <= 0 ) 663 { 664 SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); 665 break; 666 } 667 (*tag) += (char) c; 668 } 669 670 if ( in->good() ) 671 { 672 // We now have something we presume to be a node of 673 // some sort. Identify it, and call the node to 674 // continue streaming. 675 TiXmlNode* node = Identify( tag->c_str() + tagIndex, TIXML_DEFAULT_ENCODING ); 676 677 if ( node ) 678 { 679 node->StreamIn( in, tag ); 680 bool isElement = node->ToElement() != 0; 681 delete node; 682 node = 0; 683 684 // If this is the root element, we're done. Parsing will be 685 // done by the >> operator. 686 if ( isElement ) 687 { 688 return; 689 } 690 } 691 else 692 { 693 SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN ); 694 return; 695 } 696 } 697 } 698 // We should have returned sooner. 699 SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN ); 700} 701 702#endif 703 704const char* TiXmlDocument::Parse( const char* p, TiXmlParsingData* prevData, TiXmlEncoding encoding ) 705{ 706 ClearError(); 707 708 // Parse away, at the document level. Since a document 709 // contains nothing but other tags, most of what happens 710 // here is skipping white space. 711 if ( !p || !*p ) 712 { 713 SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); 714 return 0; 715 } 716 717 // Note that, for a document, this needs to come 718 // before the while space skip, so that parsing 719 // starts from the pointer we are given. 720 location.Clear(); 721 if ( prevData ) 722 { 723 location.row = prevData->cursor.row; 724 location.col = prevData->cursor.col; 725 } 726 else 727 { 728 location.row = 0; 729 location.col = 0; 730 } 731 TiXmlParsingData data( p, TabSize(), location.row, location.col ); 732 location = data.Cursor(); 733 734 if ( encoding == TIXML_ENCODING_UNKNOWN ) 735 { 736 // Check for the Microsoft UTF-8 lead bytes. 737 const unsigned char* pU = (const unsigned char*)p; 738 if ( *(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0 739 && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1 740 && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2 ) 741 { 742 encoding = TIXML_ENCODING_UTF8; 743 useMicrosoftBOM = true; 744 } 745 } 746 747 p = SkipWhiteSpace( p, encoding ); 748 if ( !p ) 749 { 750 SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN ); 751 return 0; 752 } 753 754 while ( p && *p ) 755 { 756 TiXmlNode* node = Identify( p, encoding ); 757 if ( node ) 758 { 759 p = node->Parse( p, &data, encoding ); 760 LinkEndChild( node ); 761 } 762 else 763 { 764 break; 765 } 766 767 // Did we get encoding info? 768 if ( encoding == TIXML_ENCODING_UNKNOWN 769 && node->ToDeclaration() ) 770 { 771 TiXmlDeclaration* dec = node->ToDeclaration(); 772 const char* enc = dec->Encoding(); 773 assert( enc ); 774 775 if ( *enc == 0 ) 776 encoding = TIXML_ENCODING_UTF8; 777 else if ( StringEqual( enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN ) ) 778 encoding = TIXML_ENCODING_UTF8; 779 else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) ) 780 encoding = TIXML_ENCODING_UTF8; // incorrect, but be nice 781 else 782 encoding = TIXML_ENCODING_LEGACY; 783 } 784 785 p = SkipWhiteSpace( p, encoding ); 786 } 787 788 // Was this empty? 789 if ( !firstChild ) { 790 SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, encoding ); 791 return 0; 792 } 793 794 // All is well. 795 return p; 796} 797 798void TiXmlDocument::SetError( int err, const char* pError, TiXmlParsingData* data, TiXmlEncoding encoding ) 799{ 800 // The first error in a chain is more accurate - don't set again! 801 if ( error ) 802 return; 803 804 assert( err > 0 && err < TIXML_ERROR_STRING_COUNT ); 805 error = true; 806 errorId = err; 807 errorDesc = errorString[ errorId ]; 808 809 errorLocation.Clear(); 810 if ( pError && data ) 811 { 812 data->Stamp( pError, encoding ); 813 errorLocation = data->Cursor(); 814 } 815} 816 817 818TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding ) 819{ 820 TiXmlNode* returnNode = 0; 821 822 p = SkipWhiteSpace( p, encoding ); 823 if( !p || !*p || *p != '<' ) 824 { 825 return 0; 826 } 827 828 p = SkipWhiteSpace( p, encoding ); 829 830 if ( !p || !*p ) 831 { 832 return 0; 833 } 834 835 // What is this thing? 836 // - Elements start with a letter or underscore, but xml is reserved. 837 // - Comments: <!-- 838 // - Decleration: <?xml 839 // - Everthing else is unknown to tinyxml. 840 // 841 842 const char* xmlHeader = { "<?xml" }; 843 const char* commentHeader = { "<!--" }; 844 const char* dtdHeader = { "<!" }; 845 const char* cdataHeader = { "<![CDATA[" }; 846 847 if ( StringEqual( p, xmlHeader, true, encoding ) ) 848 { 849 #ifdef DEBUG_PARSER 850 TIXML_LOG( "XML parsing Declaration\n" ); 851 #endif 852 returnNode = new TiXmlDeclaration(); 853 } 854 else if ( StringEqual( p, commentHeader, false, encoding ) ) 855 { 856 #ifdef DEBUG_PARSER 857 TIXML_LOG( "XML parsing Comment\n" ); 858 #endif 859 returnNode = new TiXmlComment(); 860 } 861 else if ( StringEqual( p, cdataHeader, false, encoding ) ) 862 { 863 #ifdef DEBUG_PARSER 864 TIXML_LOG( "XML parsing CDATA\n" ); 865 #endif 866 TiXmlText* text = new TiXmlText( "" ); 867 text->SetCDATA( true ); 868 returnNode = text; 869 } 870 else if ( StringEqual( p, dtdHeader, false, encoding ) ) 871 { 872 #ifdef DEBUG_PARSER 873 TIXML_LOG( "XML parsing Unknown(1)\n" ); 874 #endif 875 returnNode = new TiXmlUnknown(); 876 } 877 else if ( IsAlpha( *(p+1), encoding ) 878 || *(p+1) == '_' ) 879 { 880 #ifdef DEBUG_PARSER 881 TIXML_LOG( "XML parsing Element\n" ); 882 #endif 883 returnNode = new TiXmlElement( "" ); 884 } 885 else 886 { 887 #ifdef DEBUG_PARSER 888 TIXML_LOG( "XML parsing Unknown(2)\n" ); 889 #endif 890 returnNode = new TiXmlUnknown(); 891 } 892 893 if ( returnNode ) 894 { 895 // Set the parent, so it can report errors 896 returnNode->parent = this; 897 } 898 return returnNode; 899} 900 901#ifdef TIXML_USE_STL 902 903void TiXmlElement::StreamIn (std::istream * in, TIXML_STRING * tag) 904{ 905 // We're called with some amount of pre-parsing. That is, some of "this" 906 // element is in "tag". Go ahead and stream to the closing ">" 907 while( in->good() ) 908 { 909 int c = in->get(); 910 if ( c <= 0 ) 911 { 912 TiXmlDocument* document = GetDocument(); 913 if ( document ) 914 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); 915 return; 916 } 917 (*tag) += (char) c ; 918 919 if ( c == '>' ) 920 break; 921 } 922 923 if ( tag->length() < 3 ) return; 924 925 // Okay...if we are a "/>" tag, then we're done. We've read a complete tag. 926 // If not, identify and stream. 927 928 if ( tag->at( tag->length() - 1 ) == '>' 929 && tag->at( tag->length() - 2 ) == '/' ) 930 { 931 // All good! 932 return; 933 } 934 else if ( tag->at( tag->length() - 1 ) == '>' ) 935 { 936 // There is more. Could be: 937 // text 938 // cdata text (which looks like another node) 939 // closing tag 940 // another node. 941 for ( ;; ) 942 { 943 StreamWhiteSpace( in, tag ); 944 945 // Do we have text? 946 if ( in->good() && in->peek() != '<' ) 947 { 948 // Yep, text. 949 TiXmlText text( "" ); 950 text.StreamIn( in, tag ); 951 952 // What follows text is a closing tag or another node. 953 // Go around again and figure it out. 954 continue; 955 } 956 957 // We now have either a closing tag...or another node. 958 // We should be at a "<", regardless. 959 if ( !in->good() ) return; 960 assert( in->peek() == '<' ); 961 int tagIndex = (int) tag->length(); 962 963 bool closingTag = false; 964 bool firstCharFound = false; 965 966 for( ;; ) 967 { 968 if ( !in->good() ) 969 return; 970 971 int c = in->peek(); 972 if ( c <= 0 ) 973 { 974 TiXmlDocument* document = GetDocument(); 975 if ( document ) 976 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); 977 return; 978 } 979 980 if ( c == '>' ) 981 break; 982 983 *tag += (char) c; 984 in->get(); 985 986 // Early out if we find the CDATA id. 987 if ( c == '[' && tag->size() >= 9 ) 988 { 989 size_t len = tag->size(); 990 const char* start = tag->c_str() + len - 9; 991 if ( strcmp( start, "<![CDATA[" ) == 0 ) { 992 assert( !closingTag ); 993 break; 994 } 995 } 996 997 if ( !firstCharFound && c != '<' && !IsWhiteSpace( c ) ) 998 { 999 firstCharFound = true; 1000 if ( c == '/' ) 1001 closingTag = true; 1002 } 1003 } 1004 // If it was a closing tag, then read in the closing '>' to clean up the input stream. 1005 // If it was not, the streaming will be done by the tag. 1006 if ( closingTag ) 1007 { 1008 if ( !in->good() ) 1009 return; 1010 1011 int c = in->get(); 1012 if ( c <= 0 ) 1013 { 1014 TiXmlDocument* document = GetDocument(); 1015 if ( document ) 1016 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); 1017 return; 1018 } 1019 assert( c == '>' ); 1020 *tag += (char) c; 1021 1022 // We are done, once we've found our closing tag. 1023 return; 1024 } 1025 else 1026 { 1027 // If not a closing tag, id it, and stream. 1028 const char* tagloc = tag->c_str() + tagIndex; 1029 TiXmlNode* node = Identify( tagloc, TIXML_DEFAULT_ENCODING ); 1030 if ( !node ) 1031 return; 1032 node->StreamIn( in, tag ); 1033 delete node; 1034 node = 0; 1035 1036 // No return: go around from the beginning: text, closing tag, or node. 1037 } 1038 } 1039 } 1040} 1041#endif 1042 1043const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) 1044{ 1045 p = SkipWhiteSpace( p, encoding ); 1046 TiXmlDocument* document = GetDocument(); 1047 1048 if ( !p || !*p ) 1049 { 1050 if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, 0, 0, encoding ); 1051 return 0; 1052 } 1053 1054 if ( data ) 1055 { 1056 data->Stamp( p, encoding ); 1057 location = data->Cursor(); 1058 } 1059 1060 if ( *p != '<' ) 1061 { 1062 if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, p, data, encoding ); 1063 return 0; 1064 } 1065 1066 p = SkipWhiteSpace( p+1, encoding ); 1067 1068 // Read the name. 1069 const char* pErr = p; 1070 1071 p = ReadName( p, &value, encoding ); 1072 if ( !p || !*p ) 1073 { 1074 if ( document ) document->SetError( TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME, pErr, data, encoding ); 1075 return 0; 1076 } 1077 1078 TIXML_STRING endTag ("</"); 1079 endTag += value; 1080 1081 // Check for and read attributes. Also look for an empty 1082 // tag or an end tag. 1083 while ( p && *p ) 1084 { 1085 pErr = p; 1086 p = SkipWhiteSpace( p, encoding ); 1087 if ( !p || !*p ) 1088 { 1089 if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding ); 1090 return 0; 1091 } 1092 if ( *p == '/' ) 1093 { 1094 ++p; 1095 // Empty tag. 1096 if ( *p != '>' ) 1097 { 1098 if ( document ) document->SetError( TIXML_ERROR_PARSING_EMPTY, p, data, encoding ); 1099 return 0; 1100 } 1101 return (p+1); 1102 } 1103 else if ( *p == '>' ) 1104 { 1105 // Done with attributes (if there were any.) 1106 // Read the value -- which can include other 1107 // elements -- read the end tag, and return. 1108 ++p; 1109 p = ReadValue( p, data, encoding ); // Note this is an Element method, and will set the error if one happens. 1110 if ( !p || !*p ) { 1111 // We were looking for the end tag, but found nothing. 1112 // Fix for [ 1663758 ] Failure to report error on bad XML 1113 if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding ); 1114 return 0; 1115 } 1116 1117 // We should find the end tag now 1118 // note that: 1119 // </foo > and 1120 // </foo> 1121 // are both valid end tags. 1122 if ( StringEqual( p, endTag.c_str(), false, encoding ) ) 1123 { 1124 p += endTag.length(); 1125 p = SkipWhiteSpace( p, encoding ); 1126 if ( p && *p && *p == '>' ) { 1127 ++p; 1128 return p; 1129 } 1130 if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding ); 1131 return 0; 1132 } 1133 else 1134 { 1135 if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding ); 1136 return 0; 1137 } 1138 } 1139 else 1140 { 1141 // Try to read an attribute: 1142 TiXmlAttribute* attrib = new TiXmlAttribute(); 1143 if ( !attrib ) 1144 { 1145 return 0; 1146 } 1147 1148 attrib->SetDocument( document ); 1149 pErr = p; 1150 p = attrib->Parse( p, data, encoding ); 1151 1152 if ( !p || !*p ) 1153 { 1154 if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, pErr, data, encoding ); 1155 delete attrib; 1156 return 0; 1157 } 1158 1159 // Handle the strange case of double attributes: 1160 #ifdef TIXML_USE_STL 1161 TiXmlAttribute* node = attributeSet.Find( attrib->NameTStr() ); 1162 #else 1163 TiXmlAttribute* node = attributeSet.Find( attrib->Name() ); 1164 #endif 1165 if ( node ) 1166 { 1167 if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, pErr, data, encoding ); 1168 delete attrib; 1169 return 0; 1170 } 1171 1172 attributeSet.Add( attrib ); 1173 } 1174 } 1175 return p; 1176} 1177 1178 1179const char* TiXmlElement::ReadValue( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) 1180{ 1181 TiXmlDocument* document = GetDocument(); 1182 1183 // Read in text and elements in any order. 1184 const char* pWithWhiteSpace = p; 1185 p = SkipWhiteSpace( p, encoding ); 1186 1187 while ( p && *p ) 1188 { 1189 if ( *p != '<' ) 1190 { 1191 // Take what we have, make a text element. 1192 TiXmlText* textNode = new TiXmlText( "" ); 1193 1194 if ( !textNode ) 1195 { 1196 return 0; 1197 } 1198 1199 if ( TiXmlBase::IsWhiteSpaceCondensed() ) 1200 { 1201 p = textNode->Parse( p, data, encoding ); 1202 } 1203 else 1204 { 1205 // Special case: we want to keep the white space 1206 // so that leading spaces aren't removed. 1207 p = textNode->Parse( pWithWhiteSpace, data, encoding ); 1208 } 1209 1210 if ( !textNode->Blank() ) 1211 LinkEndChild( textNode ); 1212 else 1213 delete textNode; 1214 } 1215 else 1216 { 1217 // We hit a '<' 1218 // Have we hit a new element or an end tag? This could also be 1219 // a TiXmlText in the "CDATA" style. 1220 if ( StringEqual( p, "</", false, encoding ) ) 1221 { 1222 return p; 1223 } 1224 else 1225 { 1226 TiXmlNode* node = Identify( p, encoding ); 1227 if ( node ) 1228 { 1229 p = node->Parse( p, data, encoding ); 1230 LinkEndChild( node ); 1231 } 1232 else 1233 { 1234 return 0; 1235 } 1236 } 1237 } 1238 pWithWhiteSpace = p; 1239 p = SkipWhiteSpace( p, encoding ); 1240 } 1241 1242 if ( !p ) 1243 { 1244 if ( document ) document->SetError( TIXML_ERROR_READING_ELEMENT_VALUE, 0, 0, encoding ); 1245 } 1246 return p; 1247} 1248 1249 1250#ifdef TIXML_USE_STL 1251void TiXmlUnknown::StreamIn( std::istream * in, TIXML_STRING * tag ) 1252{ 1253 while ( in->good() ) 1254 { 1255 int c = in->get(); 1256 if ( c <= 0 ) 1257 { 1258 TiXmlDocument* document = GetDocument(); 1259 if ( document ) 1260 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); 1261 return; 1262 } 1263 (*tag) += (char) c; 1264 1265 if ( c == '>' ) 1266 { 1267 // All is well. 1268 return; 1269 } 1270 } 1271} 1272#endif 1273 1274 1275const char* TiXmlUnknown::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) 1276{ 1277 TiXmlDocument* document = GetDocument(); 1278 p = SkipWhiteSpace( p, encoding ); 1279 1280 if ( data ) 1281 { 1282 data->Stamp( p, encoding ); 1283 location = data->Cursor(); 1284 } 1285 if ( !p || !*p || *p != '<' ) 1286 { 1287 if ( document ) document->SetError( TIXML_ERROR_PARSING_UNKNOWN, p, data, encoding ); 1288 return 0; 1289 } 1290 ++p; 1291 value = ""; 1292 1293 while ( p && *p && *p != '>' ) 1294 { 1295 value += *p; 1296 ++p; 1297 } 1298 1299 if ( !p ) 1300 { 1301 if ( document ) 1302 document->SetError( TIXML_ERROR_PARSING_UNKNOWN, 0, 0, encoding ); 1303 } 1304 if ( p && *p == '>' ) 1305 return p+1; 1306 return p; 1307} 1308 1309#ifdef TIXML_USE_STL 1310void TiXmlComment::StreamIn( std::istream * in, TIXML_STRING * tag ) 1311{ 1312 while ( in->good() ) 1313 { 1314 int c = in->get(); 1315 if ( c <= 0 ) 1316 { 1317 TiXmlDocument* document = GetDocument(); 1318 if ( document ) 1319 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); 1320 return; 1321 } 1322 1323 (*tag) += (char) c; 1324 1325 if ( c == '>' 1326 && tag->at( tag->length() - 2 ) == '-' 1327 && tag->at( tag->length() - 3 ) == '-' ) 1328 { 1329 // All is well. 1330 return; 1331 } 1332 } 1333} 1334#endif 1335 1336 1337const char* TiXmlComment::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) 1338{ 1339 TiXmlDocument* document = GetDocument(); 1340 value = ""; 1341 1342 p = SkipWhiteSpace( p, encoding ); 1343 1344 if ( data ) 1345 { 1346 data->Stamp( p, encoding ); 1347 location = data->Cursor(); 1348 } 1349 const char* startTag = "<!--"; 1350 const char* endTag = "-->"; 1351 1352 if ( !StringEqual( p, startTag, false, encoding ) ) 1353 { 1354 if ( document ) 1355 document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding ); 1356 return 0; 1357 } 1358 p += strlen( startTag ); 1359 1360 // [ 1475201 ] TinyXML parses entities in comments 1361 // Oops - ReadText doesn't work, because we don't want to parse the entities. 1362 // p = ReadText( p, &value, false, endTag, false, encoding ); 1363 // 1364 // from the XML spec: 1365 /* 1366 [Definition: Comments may appear anywhere in a document outside other markup; in addition, 1367 they may appear within the document type declaration at places allowed by the grammar. 1368 They are not part of the document's character data; an XML processor MAY, but need not, 1369 make it possible for an application to retrieve the text of comments. For compatibility, 1370 the string "--" (double-hyphen) MUST NOT occur within comments.] Parameter entity 1371 references MUST NOT be recognized within comments. 1372 1373 An example of a comment: 1374 1375 <!-- declarations for <head> & <body> --> 1376 */ 1377 1378 value = ""; 1379 // Keep all the white space. 1380 while ( p && *p && !StringEqual( p, endTag, false, encoding ) ) 1381 { 1382 value.append( p, 1 ); 1383 ++p; 1384 } 1385 if ( p && *p ) 1386 p += strlen( endTag ); 1387 1388 return p; 1389} 1390 1391 1392const char* TiXmlAttribute::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) 1393{ 1394 p = SkipWhiteSpace( p, encoding ); 1395 if ( !p || !*p ) return 0; 1396 1397 if ( data ) 1398 { 1399 data->Stamp( p, encoding ); 1400 location = data->Cursor(); 1401 } 1402 // Read the name, the '=' and the value. 1403 const char* pErr = p; 1404 p = ReadName( p, &name, encoding ); 1405 if ( !p || !*p ) 1406 { 1407 if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding ); 1408 return 0; 1409 } 1410 p = SkipWhiteSpace( p, encoding ); 1411 if ( !p || !*p || *p != '=' ) 1412 { 1413 if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); 1414 return 0; 1415 } 1416 1417 ++p; // skip '=' 1418 p = SkipWhiteSpace( p, encoding ); 1419 if ( !p || !*p ) 1420 { 1421 if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); 1422 return 0; 1423 } 1424 1425 const char* end; 1426 const char SINGLE_QUOTE = '\''; 1427 const char DOUBLE_QUOTE = '\"'; 1428 1429 if ( *p == SINGLE_QUOTE ) 1430 { 1431 ++p; 1432 end = "\'"; // single quote in string 1433 p = ReadText( p, &value, false, end, false, encoding ); 1434 } 1435 else if ( *p == DOUBLE_QUOTE ) 1436 { 1437 ++p; 1438 end = "\""; // double quote in string 1439 p = ReadText( p, &value, false, end, false, encoding ); 1440 } 1441 else 1442 { 1443 // All attribute values should be in single or double quotes. 1444 // But this is such a common error that the parser will try 1445 // its best, even without them. 1446 value = ""; 1447 while ( p && *p // existence 1448 && !IsWhiteSpace( *p ) // whitespace 1449 && *p != '/' && *p != '>' ) // tag end 1450 { 1451 if ( *p == SINGLE_QUOTE || *p == DOUBLE_QUOTE ) { 1452 // [ 1451649 ] Attribute values with trailing quotes not handled correctly 1453 // We did not have an opening quote but seem to have a 1454 // closing one. Give up and throw an error. 1455 if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding ); 1456 return 0; 1457 } 1458 value += *p; 1459 ++p; 1460 } 1461 } 1462 return p; 1463} 1464 1465#ifdef TIXML_USE_STL 1466void TiXmlText::StreamIn( std::istream * in, TIXML_STRING * tag ) 1467{ 1468 while ( in->good() ) 1469 { 1470 int c = in->peek(); 1471 if ( !cdata && (c == '<' ) ) 1472 { 1473 return; 1474 } 1475 if ( c <= 0 ) 1476 { 1477 TiXmlDocument* document = GetDocument(); 1478 if ( document ) 1479 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); 1480 return; 1481 } 1482 1483 (*tag) += (char) c; 1484 in->get(); // "commits" the peek made above 1485 1486 if ( cdata && c == '>' && tag->size() >= 3 ) { 1487 size_t len = tag->size(); 1488 if ( (*tag)[len-2] == ']' && (*tag)[len-3] == ']' ) { 1489 // terminator of cdata. 1490 return; 1491 } 1492 } 1493 } 1494} 1495#endif 1496 1497const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding ) 1498{ 1499 value = ""; 1500 TiXmlDocument* document = GetDocument(); 1501 1502 if ( data ) 1503 { 1504 data->Stamp( p, encoding ); 1505 location = data->Cursor(); 1506 } 1507 1508 const char* const startTag = "<![CDATA["; 1509 const char* const endTag = "]]>"; 1510 1511 if ( cdata || StringEqual( p, startTag, false, encoding ) ) 1512 { 1513 cdata = true; 1514 1515 if ( !StringEqual( p, startTag, false, encoding ) ) 1516 { 1517 if ( document ) 1518 document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding ); 1519 return 0; 1520 } 1521 p += strlen( startTag ); 1522 1523 // Keep all the white space, ignore the encoding, etc. 1524 while ( p && *p 1525 && !StringEqual( p, endTag, false, encoding ) 1526 ) 1527 { 1528 value += *p; 1529 ++p; 1530 } 1531 1532 TIXML_STRING dummy; 1533 p = ReadText( p, &dummy, false, endTag, false, encoding ); 1534 return p; 1535 } 1536 else 1537 { 1538 bool ignoreWhite = true; 1539 1540 const char* end = "<"; 1541 p = ReadText( p, &value, ignoreWhite, end, false, encoding ); 1542 if ( p && *p ) 1543 return p-1; // don't truncate the '<' 1544 return 0; 1545 } 1546} 1547 1548#ifdef TIXML_USE_STL 1549void TiXmlDeclaration::StreamIn( std::istream * in, TIXML_STRING * tag ) 1550{ 1551 while ( in->good() ) 1552 { 1553 int c = in->get(); 1554 if ( c <= 0 ) 1555 { 1556 TiXmlDocument* document = GetDocument(); 1557 if ( document ) 1558 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN ); 1559 return; 1560 } 1561 (*tag) += (char) c; 1562 1563 if ( c == '>' ) 1564 { 1565 // All is well. 1566 return; 1567 } 1568 } 1569} 1570#endif 1571 1572const char* TiXmlDeclaration::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding _encoding ) 1573{ 1574 p = SkipWhiteSpace( p, _encoding ); 1575 // Find the beginning, find the end, and look for 1576 // the stuff in-between. 1577 TiXmlDocument* document = GetDocument(); 1578 if ( !p || !*p || !StringEqual( p, "<?xml", true, _encoding ) ) 1579 { 1580 if ( document ) document->SetError( TIXML_ERROR_PARSING_DECLARATION, 0, 0, _encoding ); 1581 return 0; 1582 } 1583 if ( data ) 1584 { 1585 data->Stamp( p, _encoding ); 1586 location = data->Cursor(); 1587 } 1588 p += 5; 1589 1590 version = ""; 1591 encoding = ""; 1592 standalone = ""; 1593 1594 while ( p && *p ) 1595 { 1596 if ( *p == '>' ) 1597 { 1598 ++p; 1599 return p; 1600 } 1601 1602 p = SkipWhiteSpace( p, _encoding ); 1603 if ( StringEqual( p, "version", true, _encoding ) ) 1604 { 1605 TiXmlAttribute attrib; 1606 p = attrib.Parse( p, data, _encoding ); 1607 version = attrib.Value(); 1608 } 1609 else if ( StringEqual( p, "encoding", true, _encoding ) ) 1610 { 1611 TiXmlAttribute attrib; 1612 p = attrib.Parse( p, data, _encoding ); 1613 encoding = attrib.Value(); 1614 } 1615 else if ( StringEqual( p, "standalone", true, _encoding ) ) 1616 { 1617 TiXmlAttribute attrib; 1618 p = attrib.Parse( p, data, _encoding ); 1619 standalone = attrib.Value(); 1620 } 1621 else 1622 { 1623 // Read over whatever it is. 1624 while( p && *p && *p != '>' && !IsWhiteSpace( *p ) ) 1625 ++p; 1626 } 1627 } 1628 return 0; 1629} 1630 1631bool TiXmlText::Blank() const 1632{ 1633 for ( unsigned i=0; i<value.length(); i++ ) 1634 if ( !IsWhiteSpace( value[i] ) ) 1635 return false; 1636 return true; 1637} 1638 1639