tinyxml.c

一个简单的xml解析代码

            }
            node->Print( cfile, depth + 1 );
        }
        fprintf( cfile, "\n" );
        for( i = 0; i < depth; ++i )
            fprintf( cfile, "    " );
        fprintf( cfile, "</%s>", value.c_str() );
    }
}

void TiXmlElement::StreamOut( TIXML_OSTREAM * stream ) const {
    ( *stream ) << "<" << value;

    TiXmlAttribute* attrib;
    for( attrib = attributeSet.First(); attrib; attrib = attrib->Next() ) {
        ( *stream ) << " ";
        attrib->StreamOut( stream );
    }

    // If this node has children, give it a closing tag. Else
    // make it an empty tag.
    TiXmlNode* node;
    if( firstChild ) {
        ( *stream ) << ">";

        for( node = firstChild; node; node = node->NextSibling() ) {
            node->StreamOut( stream );
        }
        ( *stream ) << "</" << value << ">";
    } else {
        ( *stream ) << " />";
    }
}

TiXmlNode* TiXmlElement::Clone() const {
    TiXmlElement * clone = new TiXmlElement( Value() );
    if( !clone )
        return 0;

    CopyToClone( clone );

    // Clone the attributes, then clone the children.
    TiXmlAttribute* attribute = 0;
    for( attribute = attributeSet.First();
       attribute;
       attribute = attribute->Next() ) {
        clone->SetAttribute( attribute->Name(), attribute->Value() );
    }

    TiXmlNode* node = 0;
    for( node = firstChild; node; node = node->NextSibling() ) {
        clone->LinkEndChild( node->Clone() );
    }
    return clone;
}


TiXmlDocument::TiXmlDocument() : TiXmlNode( TiXmlNode::DOCUMENT ) {
    error = false;
    //	ignoreWhiteSpace = true;
}

TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::DOCUMENT ) {
    //	ignoreWhiteSpace = true;
    value = documentName;
    error = false;
}

bool TiXmlDocument::LoadFile() {
    // See STL_STRING_BUG below.
    StringToBuffer buf( value );

    if( buf.buffer && LoadFile( buf.buffer ) )
        return true;

    return false;
}


bool TiXmlDocument::SaveFile() const {
    // See STL_STRING_BUG below.
    StringToBuffer buf( value );

    if( buf.buffer && SaveFile( buf.buffer ) )
        return true;

    return false;
}

bool TiXmlDocument::LoadFile( const char* filename ) {
    // Delete the existing data:
    Clear();

    // There was a really terrifying little bug here. The code:
    //		value = filename
    // in the STL case, cause the assignment method of the std::string to
    // be called. What is strange, is that the std::string had the same
    // address as it's c_str() method, and so bad things happen. Looks
    // like a bug in the Microsoft STL implementation.
    // See STL_STRING_BUG above.
    // Fixed with the StringToBuffer class.
    value = filename;

    FILE* file = fopen( value.c_str (), "r" );

    if( file ) {
        // Get the file size, so we can pre-allocate the string. HUGE speed impact.
        long length = 0;
        fseek( file, 0, SEEK_END );
        length = ftell( file );
        fseek( file, 0, SEEK_SET );

        // Strange case, but good to handle up front.
        if( length == 0 ) {
            fclose( file );
            return false;
        }

        // If we have a file, assume it is all one big XML file, and read it in.
        // The document parser may decide the document ends sooner than the entire file, however.
        TIXML_STRING data;
        data.reserve( length );

        const int BUF_SIZE = 2048;
        char buf[ BUF_SIZE ];

        while( fgets( buf, BUF_SIZE, file ) ) {
            data += buf;
        }
        fclose( file );

        Parse( data.c_str() );
        if( Error() )
            return false;
        else
            return true;
    }
    SetError( TIXML_ERROR_OPENING_FILE );
    return false;
}

bool TiXmlDocument::SaveFile( const char * filename ) const {
    // The old c stuff lives on...
    FILE * fp = fopen( filename, "w" );
    if( fp ) {
        Print( fp, 0 );
        fclose( fp );
        return true;
    }
    return false;
}


TiXmlNode* TiXmlDocument::Clone() const {
    TiXmlDocument * clone = new TiXmlDocument();
    if( !clone )
        return 0;

    CopyToClone( clone );
    clone->error = error;
    clone->errorDesc = errorDesc.c_str ();

    TiXmlNode* node = 0;
    for( node = firstChild; node; node = node->NextSibling() ) {
        clone->LinkEndChild( node->Clone() );
    }
    return clone;
}


void TiXmlDocument::Print( FILE* cfile, int depth ) const {
    TiXmlNode * node;
    for( node = FirstChild(); node; node = node->NextSibling() ) {
        node->Print( cfile, depth );
        fprintf( cfile, "\n" );
    }
}

void TiXmlDocument::StreamOut( TIXML_OSTREAM * out ) const {
    TiXmlNode * node;
    for( node = FirstChild(); node; node = node->NextSibling() ) {
        node->StreamOut( out );

        // Special rule for streams: stop after the root element.
        // The stream in code will only read one element, so don't
        // write more than one.
        if( node->ToElement() )
            break;
    }
}

TiXmlAttribute* TiXmlAttribute::Next() const {
    // We are using knowledge of the sentinel. The sentinel
    // have a value or name.
    if( next->value.empty() && next->name.empty() )
        return 0;
    return next;
}


TiXmlAttribute* TiXmlAttribute::Previous() const {
    // We are using knowledge of the sentinel. The sentinel
    // have a value or name.
    if( prev->value.empty() && prev->name.empty() )
        return 0;
    return prev;
}


void TiXmlAttribute::Print( FILE* cfile, int /*depth*/ ) const {
    TIXML_STRING n, v;

    PutString( Name(), &n );
    PutString( Value(), &v );

    if( value.find ( '\"' ) == TIXML_STRING::npos )
        fprintf ( cfile, "%s=\"%s\"", n.c_str(), v.c_str() );
    else
        fprintf ( cfile, "%s='%s'", n.c_str(), v.c_str() );
}


void TiXmlAttribute::StreamOut( TIXML_OSTREAM * stream ) const {
    if( value.find( '\"' ) != TIXML_STRING::npos ) {
        PutString( name, stream );
        ( *stream ) << "=" << "'";
        PutString( value, stream );
        ( *stream ) << "'";
    } else {
        PutString( name, stream );
        ( *stream ) << "=" << "\"";
        PutString( value, stream );
        ( *stream ) << "\"";
    }
}

void TiXmlAttribute::SetIntValue( int value ) {
    char buf [ 64 ];
    sprintf ( buf, "%d", value );
    SetValue ( buf );
}

void TiXmlAttribute::SetDoubleValue( double value ) {
    char buf [ 64 ];
    sprintf ( buf, "%lf", value );
    SetValue ( buf );
}

const int TiXmlAttribute::IntValue() const {
    return atoi ( value.c_str () );
}

const double TiXmlAttribute::DoubleValue() const {
    return atof ( value.c_str () );
}

void TiXmlComment::Print( FILE* cfile, int depth ) const {
    for( int i = 0; i < depth; i++ ) {
        fputs( "    ", cfile );
    }
    fprintf( cfile, "<!--%s-->", value.c_str() );
}

void TiXmlComment::StreamOut( TIXML_OSTREAM * stream ) const {
    ( *stream ) << "<!--";
    PutString( value, stream );
    ( *stream ) << "-->";
}

TiXmlNode* TiXmlComment::Clone() const {
    TiXmlComment * clone = new TiXmlComment();

    if( !clone )
        return 0;

    CopyToClone( clone );
    return clone;
}


void TiXmlText::Print( FILE* cfile, int /*depth*/ ) const {
    TIXML_STRING buffer;
    PutString( value, &buffer );
    fprintf( cfile, "%s", buffer.c_str() );
}


void TiXmlText::StreamOut( TIXML_OSTREAM * stream ) const {
    PutString( value, stream );
}


TiXmlNode* TiXmlText::Clone() const {
    TiXmlText * clone = 0;
    clone = new TiXmlText( "" );

    if( !clone )
        return 0;

    CopyToClone( clone );
    return clone;
}


TiXmlDeclaration::TiXmlDeclaration( const char * _version,
                                    const char * _encoding,
                                    const char * _standalone )
: TiXmlNode( TiXmlNode::DECLARATION ) {
    version = _version;
    encoding = _encoding;
    standalone = _standalone;
}


void TiXmlDeclaration::Print( FILE* cfile, int /*depth*/ ) const {
    fprintf ( cfile, "<?xml " );

    if( !version.empty() )
        fprintf ( cfile, "version=\"%s\" ", version.c_str () );
    if( !encoding.empty() )
        fprintf ( cfile, "encoding=\"%s\" ", encoding.c_str () );
    if( !standalone.empty() )
        fprintf ( cfile, "standalone=\"%s\" ", standalone.c_str () );
    fprintf ( cfile, "?>" );
}

void TiXmlDeclaration::StreamOut( TIXML_OSTREAM * stream ) const {
    ( *stream ) << "<?xml ";

    if( !version.empty() ) {
        ( *stream ) << "version=\"";
        PutString( version, stream );
        ( *stream ) << "\" ";
    }
    if( !encoding.empty() ) {
        ( *stream ) << "encoding=\"";
        PutString( encoding, stream );
        ( *stream ) << "\" ";
    }
    if( !standalone.empty() ) {
        ( *stream ) << "standalone=\"";
        PutString( standalone, stream );
        ( *stream ) << "\" ";
    }
    ( *stream ) << "?>";
}

TiXmlNode* TiXmlDeclaration::Clone() const {
    TiXmlDeclaration * clone = new TiXmlDeclaration();

    if( !clone )
        return 0;

    CopyToClone( clone );
    clone->version = version;
    clone->encoding = encoding;
    clone->standalone = standalone;
    return clone;
}


void TiXmlUnknown::Print( FILE* cfile, int depth ) const {
    for( int i = 0; i < depth; i++ )
        fprintf( cfile, "    " );
    fprintf( cfile, "%s", value.c_str() );
}

void TiXmlUnknown::StreamOut( TIXML_OSTREAM * stream ) const {
    ( *stream ) << "<" << value << ">";     // Don't use entities hear! It is unknown.
}

TiXmlNode* TiXmlUnknown::Clone() const {
    TiXmlUnknown * clone = new TiXmlUnknown();

    if( !clone )
        return 0;

    CopyToClone( clone );
    return clone;
}


TiXmlAttributeSet::TiXmlAttributeSet() {
    sentinel.next = &sentinel;
    sentinel.prev = &sentinel;
}


TiXmlAttributeSet::~TiXmlAttributeSet() {
    assert( sentinel.next == &sentinel );
    assert( sentinel.prev == &sentinel );
}


void TiXmlAttributeSet::Add( TiXmlAttribute* addMe ) {
    assert( !Find( addMe->Name() ) );   // Shouldn't be multiply adding to the set.

    addMe->next = &sentinel;
    addMe->prev = sentinel.prev;

    sentinel.prev->next = addMe;
    sentinel.prev = addMe;
}

void TiXmlAttributeSet::Remove( TiXmlAttribute* removeMe ) {
    TiXmlAttribute * node;

    for( node = sentinel.next; node != &sentinel; node = node->next ) {
        if( node == removeMe ) {
            node->prev->next = node->next;
            node->next->prev = node->prev;
            node->next = 0;
            node->prev = 0;
            return ;
        }
    }
    assert( 0 );        // we tried to remove a non-linked attribute.
}

TiXmlAttribute* TiXmlAttributeSet::Find( const char * name ) const {
    TiXmlAttribute * node;

    for( node = sentinel.next; node != &sentinel; node = node->next ) {
        if( node->name == name )
            return node;
    }
    return 0;
}


#ifdef TIXML_USE_STL
TIXML_ISTREAM & operator >> ( TIXML_ISTREAM & in, TiXmlNode & base ) {
    TIXML_STRING tag;
    tag.reserve( 8 * 1000 );
    base.StreamIn( &in, &tag );

    base.Parse( tag.c_str() );
    return in;
}
#endif


TIXML_OSTREAM & operator<< ( TIXML_OSTREAM & out, const TiXmlNode & base ) {
    base.StreamOut ( & out );
    return out;
}

/*add by yang@iip for common use*/
TiXmlDocument * loadXmlCfgFile( bool exitOnError, char *xmlFileName ) {
    if( !xmlFileName ) {
        printf( "Unknown config XML file name!\n" );
        return NULL;
    }
    //printf("xml filename: %s\n",xmlFileName);
    TiXmlDocument *pXmlTree = new TiXmlDocument( xmlFileName );
    if( !pXmlTree ) {
        printf( "(%s:%d)Alloc XML treee for %s error !", __FILE__, __LINE__, xmlFileName );
        if( exitOnError ) {
            exit( 0 );
        }
        return NULL;
    }

    if( !pXmlTree->LoadFile() ) {
        printf( "Load config file %s failed, %s", xmlFileName, pXmlTree->ErrorDesc() );
        delete pXmlTree;
        if( exitOnError ) {
            exit( 0 );
        }
        return NULL;
    }

    return( TiXmlDocument* ) pXmlTree;
}
}