/*www.sourceforge.net/projects/tinyxmlOriginal code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use thissoftware in a product, an acknowledgment in the product documentationwould be appreciated but is not required.2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.3. This notice may not be removed or altered from any source distribution.*/#include "tinyxml.h"#include <ctype.h>namespace ebtinyxml{//#define DEBUG_PARSER// Note tha "PutString" hardcodes the same list. This// is less flexible than it appears. Changing the entries// or order will break putstring.	TiXmlBase::Entity TiXmlBase::entity[ NUM_ENTITY ] = {    { "&amp;",  5, '&'},    { "&lt;",   4, '<'},    { "&gt;",   4, '>'},    { "&quot;", 6, '\"'},    { "&apos;", 6, '\''}};const char* TiXmlBase::SkipWhiteSpace( const char* p ) {    if( !p || !*p ) {        return 0;    }    while( p && *p ) {        if( isspace( *p ) || *p == '\n' || *p =='\r' ) {     // Still using old rules for white space.            /* add errorLine to provide more error information. by zhoujunfeng */            if(*p == '\n') {                errorLine++;            }            ++p;        } else            break;    }    return p;}#ifdef TIXML_USE_STL/*static*/ bool TiXmlBase::StreamWhiteSpace( TIXML_ISTREAM * in, TIXML_STRING * tag ) {    for( ;; ) {        if( !in->good() ) return false;        int c = in->peek();        if( !IsWhiteSpace( c ) )            return true;        *tag += in->get();    }}/*static*/ bool TiXmlBase::StreamTo( TIXML_ISTREAM * in, int character, TIXML_STRING * tag ) {    while( in->good() ) {        int c = in->peek();        if( c == character )            return true;        in->get();        *tag += c;    }    return false;}#endifconst char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name ) {    *name = "";    assert( p );    // Names start with letters or underscores.    // After that, they can be letters, underscores, numbers,    // hyphens, or colons. (Colons are valid ony for namespaces,    // but tinyxml can't tell namespaces from names.)    if(    p && *p            && ( isalpha( (unsigned char) *p ) || *p == '_' ) ) {        while(      p && *p                    &&  (       isalnum( (unsigned char ) *p )                                 || *p == '_'                                || *p == '-'                                || *p == '.'                                || *p == ':' ) ) {            (*name) += *p;            ++p;        }        return p;    }    return 0;}const char* TiXmlBase::GetEntity( const char* p, char* value ) {    // Presume an entity, and pull it out.    TIXML_STRING ent;    int i;    // Ignore the &#x entities.    if(    strncmp( "&#x", p, 3 ) == 0            && *(p+3)            && *(p+4) ) {        *value = 0;        if( isalpha( *(p+3) ) ) *value += ( tolower( *(p+3) ) - 'a' + 10 ) * 16;        else                     *value += ( *(p+3) - '0' ) * 16;        if( isalpha( *(p+4) ) ) *value += ( tolower( *(p+4) ) - 'a' + 10 );        else                     *value += ( *(p+4) - '0' );        return p+6;    }    // Now try to match it.    for( i=0; i<NUM_ENTITY; ++i ) {        if( strncmp( entity[i].str, p, entity[i].strLength ) == 0 ) {            assert( strlen( entity[i].str ) == entity[i].strLength );            *value = entity[i].chr;            return( p + entity[i].strLength );        }    }    // So it wasn't an entity, its unrecognized, or something like that.    *value = *p;    // Don't put back the last one, since we return it!    return p+1;}bool TiXmlBase::StringEqual( const char* p,                             const char* tag,                             bool ignoreCase ) {    assert( p );    if( !p || !*p ) {        assert( 0 );        return false;    }    if( tolower( *p ) == tolower( *tag ) ) {        const char* q = p;        if(ignoreCase) {            while( *q && *tag && *q == *tag ) {                ++q;                ++tag;            }            if( *tag == 0 ) {        // Have we found the end of the tag, and everything equal?                return true;            }        } else {            while( *q && *tag && tolower( *q ) == tolower( *tag ) ) {                ++q;                ++tag;            }            if( *tag == 0 ) {                return true;            }        }    }    return false;}const char* TiXmlBase::ReadText(    const char* p,                                     TIXML_STRING * text,                                     bool trimWhiteSpace,                                     const char* endTag,                                     bool caseInsensitive ) {    *text = "";    if(    !trimWhiteSpace         // certain tags always keep whitespace           || !condenseWhiteSpace ) {   // if true, whitespace is always kept        // Keep all the white space.        while(    p && *p                  && !StringEqual( p, endTag, caseInsensitive )             ) {            char c;            p = GetChar( p, &c );            (* text) += c;        }    } else {        bool whitespace = false;        // Remove leading white space:        p = SkipWhiteSpace( p );        while(    p && *p                  && !StringEqual( p, endTag, caseInsensitive ) ) {            if( *p == '\r' || *p == '\n' ) {                whitespace = true;                ++p;            } else if( isspace( *p ) ) {                whitespace = true;                ++p;            } else {                // If we've found whitespace, add it before the                // new character. Any whitespace just becomes a space.                if( whitespace ) {                    (* text) += ' ';                    whitespace = false;                }                char c;                p = GetChar( p, &c );                (* text) += c;            }        }    }    return p + strlen( endTag );}#ifdef TIXML_USE_STLvoid TiXmlDocument::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag ) {    // The basic issue with a document is that we don't know what we're    // streaming. Read something presumed to be a tag (and hope), then    // identify it, and call the appropriate stream method on the tag.    //    // This "pre-streaming" will never read the closing ">" so the    // sub-tag can orient itself.    if( !StreamTo( in, '<', tag ) ) {        SetError( TIXML_ERROR_PARSING_EMPTY );        return;    }    while( in->good() ) {        int tagIndex = tag->length();        while( in->good() && in->peek() != '>' ) {            int c = in->get();            (*tag) += (char) c;        }        if( in->good() ) {            // We now have something we presume to be a node of             // some sort. Identify it, and call the node to            // continue streaming.            TiXmlNode* node = Identify( tag->c_str() + tagIndex );            if( node ) {                node->StreamIn( in, tag );                bool isElement = node->ToElement() != 0;                delete node;                node = 0;                // If this is the root element, we're done. Parsing will be                // done by the >> operator.                if( isElement ) {                    return;                }            } else {                SetError( TIXML_ERROR );                return;            }        }    }    // We should have returned sooner.    SetError( TIXML_ERROR );}#endifconst char* TiXmlDocument::Parse( const char* p ) {    // Parse away, at the document level. Since a document    // contains nothing but other tags, most of what happens    // here is skipping white space.    //    // In this variant (as opposed to stream and Parse) we    // read everything we can.    /* add errorLine to provide more error information. by zhoujunfeng */    errorLine = 1;    if( !p || !*p ) {        SetError( TIXML_ERROR_DOCUMENT_EMPTY );        return(const char*)false;    }    p = SkipWhiteSpace( p );    if( !p ) {        SetError( TIXML_ERROR_DOCUMENT_EMPTY );        return(const char*)false;    }    while( p && *p ) {        TiXmlNode* node = Identify( p );        if( node ) {            p = node->Parse( p );            LinkEndChild( node );        } else {            break;        }        p = SkipWhiteSpace( p );    }    // All is well.    return p;}TiXmlNode* TiXmlNode::Identify( const char* p ) {    TiXmlNode* returnNode = 0;    p = SkipWhiteSpace( p );    if( !p || !*p || *p != '<' ) {        return 0;    }    TiXmlDocument* doc = GetDocument();    p = SkipWhiteSpace( p );    if( !p || !*p ) {        return 0;    }    // What is this thing?     // - Elements start with a letter or underscore, but xml is reserved.    // - Comments: <!--    // - Decleration: <?xml    // - Everthing else is unknown to tinyxml.    //    const char* xmlHeader = { "<?xml"};    const char* commentHeader = { "<!--"};    if( StringEqual( p, xmlHeader, true ) ) {#ifdef DEBUG_PARSER        TIXML_LOG( "XML parsing Declaration\n" );#endif        returnNode = new TiXmlDeclaration();    } else if(    isalpha( *(p+1) )                  || *(p+1) == '_' ) {#ifdef DEBUG_PARSER        TIXML_LOG( "XML parsing Element\n" );#endif        returnNode = new TiXmlElement( "" );    } else if( StringEqual( p, commentHeader, false ) ) {#ifdef DEBUG_PARSER        TIXML_LOG( "XML parsing Comment\n" );#endif        returnNode = new TiXmlComment();    } else {#ifdef DEBUG_PARSER        TIXML_LOG( "XML parsing Unknown\n" );#endif        returnNode = new TiXmlUnknown();    }    if( returnNode ) {        // Set the parent, so it can report errors        returnNode->parent = this;        //p = returnNode->Parse( p );    } else {        if( doc )            doc->SetError( TIXML_ERROR_OUT_OF_MEMORY );    }    return returnNode;}#ifdef TIXML_USE_STLvoid TiXmlElement::StreamIn (TIXML_ISTREAM * in, TIXML_STRING * tag) {    // We're called with some amount of pre-parsing. That is, some of "this"    // element is in "tag". Go ahead and stream to the closing ">"    while( in->good() ) {        int c = in->get();        (*tag) += (char) c ;        if( c == '>' )            break;    }    if( tag->length() < 3 ) return;    // Okay...if we are a "/>" tag, then we're done. We've read a complete tag.    // If not, identify and stream.    if(    tag->at( tag->length() - 1 ) == '>'            && tag->at( tag->length() - 2 ) == '/' ) {        // All good!        return;    } else if( tag->at( tag->length() - 1 ) == '>' ) {        // There is more. Could be:        //		text        //		closing tag        //		another node.        for( ;; ) {            StreamWhiteSpace( in, tag );