tinyxml源码解析(中)

前言:

　　之前趁着这段时间比较空闲,也因为听闻tinyxml大名,因此就阅读了tinyxml的源码.在上一篇博文中<tinyxml源码解析(上)>中对tinyxml整体架构以及其中两个基类TiXmlBase,TiXmlNode进行了注释解析.不过文章写得有点啰嗦,太过详细.因此这篇文章将提取其中的部分设计而不是对于每个函数进行注释.

　　本文将主要介绍tinyxml对于attribute的处理,各个元素类的简单介绍以及tinyxml的整体处理流程.

正文:

　　还是先回顾下之前看的tinyxml的结构图吧.

　　

　　从图上我们可以看到,TiXmlAttribute并不是继承与TiXmlNode中,虽然其是xml的元素之一,在实现上很多也是element的叶节点,不过tinyxml并没有这么做.可以先看下TiXmlAttribute的声明.

class TiXmlAttribute : public TiXmlBase
{
    friend class TiXmlAttributeSet;//TiXMlAttrubteSet之后我们将会看到
public:
    //....构造函数

    //返回属性的值
    const char*        Name()  const        { return name.c_str(); }        
    const char*        Value() const        { return value.c_str(); }        
    //....
    //提供了比IntValue()更好的错误检查.后头还是调用了sscanf进行处理,而IntValue则是采用了atoi
    //QueryXXXValue系列都是采用了sscanf进行处理.
    int QueryIntValue( int* _value ) const;
    int QueryDoubleValue( double* _value ) const;

    //设置值,对于有类型转化的,采用了sprintf进行处理
    void SetName( const char* _name )    { name = _name; }
    void SetValue( const char* _value )    { value = _value; }

    void SetIntValue( int _value );                        
    void SetDoubleValue( double _value );                

    //提供了string的版本
    ///...

    ///简单的比较函数
    ///....
    ///Parse将在下面统一讲解
    virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );


private:
    TiXmlAttribute( const TiXmlAttribute& );                // not implemented.
    void operator=( const TiXmlAttribute& base );    // not allowed.

    TiXmlDocument*    document;    // A pointer back to a document, for error reporting.
    TIXML_STRING name;
    TIXML_STRING value;
    TiXmlAttribute*    prev;
    TiXmlAttribute*    next;
};

　　TiXmlAttribute提供了少部分功能的转化函数.不过特殊的是其Next函数以及Previous函数的实现比较特别.

const TiXmlAttribute* TiXmlAttribute::Next() const
{
        //这里判断是否到尾部的方式是判断next的成员的值
    if ( next->value.empty() && next->name.empty() )
        return 0;
    return next;
}

const TiXmlAttribute* TiXmlAttribute::Previous() const
{
    // 这里也是
    if ( prev->value.empty() && prev->name.empty() )
        return 0;
    return prev;
}

原因在于,tinyxml使用了循环双向链表进行处理.看下面的TiXmlAttributeSet就可以看得出了.作者给出的理由是:他喜欢循环链表.另外,说明了相对于典型双向链表的独立性(这个我也没搞明白是怎么回事).

TiXmlAttributeSet是一个工具类,其负责管理Element中的attribute.提供了添加,删除,查找等功能,使得代码更为简洁.

//折叠起来总是有BUG.打不开.所以就只要不折叠了...
class TiXmlAttributeSet
{
public:
    //构造和析构函数,构造函数就是把sentinel的头尾连在一起,而析构则是两句assert,判断是否所有元素被移除.

    void Add( TiXmlAttribute* attribute );
    void Remove( TiXmlAttribute* attribute );

    //有元素返回,没元素返回null
    const TiXmlAttribute* First()    const    { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
    TiXmlAttribute* First()                    { return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
    const TiXmlAttribute* Last() const        { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
    TiXmlAttribute* Last()                    { return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }

    //查找
    TiXmlAttribute*    Find( const char* _name ) const;
    TiXmlAttribute* FindOrCreate( const char* _name );
    ///stl版本
    ///...

private:
    //因为TiXmlAttribute禁止复制,因此AttributeSet也禁止
    TiXmlAttributeSet( const TiXmlAttributeSet& );    
    void operator=( const TiXmlAttributeSet& );    

    TiXmlAttribute sentinel;//循环链表的头.其目的在于做为头和尾的区分.
};

可以看看循环链表的处理.

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

    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.

在查看了attribute的处理后,我们就可以看看element的处理了.

class TiXmlElement : public TiXmlNode
{
public:
    
    //构造,复制,析构函数
    ///...
    
    ///一系列的Attribute函数仅仅就是调用attributeset中的find,查找到后调用attribute的query函数
    ///其他都类似
    const char* Attribute( const char* name ) const
    {
        const TiXmlAttribute* node = attributeSet.Find( name );
        if ( node )
            return node->Value();
        return 0;
    }

    //set函数也不例外,就是find然后set
    void TiXmlElement::SetAttribute( const char * name, int val )
    {    
        TiXmlAttribute* attrib = attributeSet.FindOrCreate( name );
        if ( attrib ) {
            attrib->SetIntValue( val );
        }
    }
    
    //可想而知,remove肯定也是一样的,调用attributeset的函数进行处理
    void RemoveAttribute( const char * name );
    
    //获取其中第一个文字节点
    const char* GetText() const;

    /// 复制当前节点,重写了TiXmlNode的纯虚函数
    virtual TiXmlNode* Clone() const;
    //打印函数,
    virtual void Print( FILE* cfile, int depth ) const;

    //parse函数之后统一说
    virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );

    //这部分设计的很精巧.在父类TiXmlNode中,所有的ToXXXX函数返回皆为null.而在子类中相应的重写函数,使之转化成为可能.而转化成其他类的函数仍然不可以.
    virtual const TiXmlElement*     ToElement()     const { return this; } 
    virtual TiXmlElement*           ToElement()              { return this; } 

    virtual bool Accept( TiXmlVisitor* visitor ) const;

protected:
    //复制函数,提供给复制构造函数
    void CopyTo( TiXmlElement* target ) const;
    void ClearThis();
    //获取element中的值.在parse中被调用.
    const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding );

private:
    TiXmlAttributeSet attributeSet;//管理attribute列表
};

剩下的几个元素,如declaration,unknown,text,comment都和element差别不大.我们直接来看TiXmlDocument:

class TiXmlDocument : public TiXmlNode
{
public:
    //构造函数
    TiXmlDocument()
    {
        tabsize = 4;//设定输出tab格式
        useMicrosoftBOM = false;//设定是否采用ms的utf8-bom格式
        ClearError();
    }

    //复制构造函数
    TiXmlDocument( const TiXmlDocument& copy );
    TiXmlDocument& operator=( const TiXmlDocument& copy )
    {
        Clear();
        copy.CopyTo( this );//采用了private的copyTo函数
        return *this;
    }

    virtual ~TiXmlDocument() {}//析构没什么好做的
    
    //保存和读取文本函数,
    bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
    bool SaveFile( FILE* ) const;

    //分析,下面将主要分析这个函数
    virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );

    //带格式输出
    virtual void Print( FILE* cfile, int depth = 0 ) const;
    void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );

    //同TiXmlElement
    virtual const TiXmlDocument*    ToDocument()    const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
    virtual TiXmlDocument*          ToDocument()          { return this; } ///< Cast to a more defined type. Will return null not of the requested type.

    /** Walk the XML tree visiting this node and all of its children. 
    */
    virtual bool Accept( TiXmlVisitor* content ) const;

protected :
    // 重写的Clone函数
    virtual TiXmlNode* Clone() const;
    #ifdef TIXML_USE_STL
    virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
    #endif

private:
    //复制的内部函数
    void CopyTo( TiXmlDocument* target ) const;

    bool error;
    int  errorId;
    TIXML_STRING errorDesc;
    int tabsize;
    TiXmlCursor errorLocation;//定位错误,包涵了行数和列数
    bool useMicrosoftBOM;        // 使用utf-bom
};

 大部分只是简单的设置,我们就着重挑几个感兴趣的看看.

首先是文件操作,LoadFile以及SaveFile

//载入数据
bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding )
{
    if ( !file ) 
    {
        SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
        return false;
    }

    // 初始化数据
    Clear();
    location.Clear();

    // 采用fseek的方式来获取文件的大小。并且预分配数据大小，加速大文件处理
    long length = 0;
    fseek( file, 0, SEEK_END );
    length = ftell( file );
    fseek( file, 0, SEEK_SET );

    // 比较奇怪的情况。
    if ( length <= 0 )
    {
        SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );
        return false;
    }
    
    //先new需要读取的数据的大小.
    char* buf = new char[ length+1 ];
    buf[0] = 0;

    //然后一次性fread进来.
    if ( fread( buf, length, 1, file ) != 1 ) {
        delete [] buf;
        SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
        return false;
    }

    // 统一回车符,采用p,q两个指针进行处理.
    //将\r\n,\n,\r统一转化为\n.
    const char* p = buf;    // the read head
    char* q = buf;            // the write head
    const char CR = 0x0d;
    const char LF = 0x0a;

    buf[length] = 0;
    while( *p ) {
        assert( p < (buf+length) );
        assert( q <= (buf+length) );
        assert( q <= p );
        
        //是\r
        if ( *p == CR ) {
            *q++ = LF;//转化为\n,并且判断下一个字符,,如果是\n,则跳过
            p++;
            if ( *p == LF ) {        
                p++;
            }
        }
        else {
            *q++ = *p++;
        }
    }
    assert( q <= (buf+length) );
    *q = 0;

    Parse( buf, 0, encoding );//进行解析,生成xml节点树

    delete [] buf;//删除缓存的数据
    return !Error();
}
//save相对简单的多
bool TiXmlDocument::SaveFile( FILE* fp ) const
{
    //如果是ms的格式,则写一个UTF8的头
    if ( useMicrosoftBOM ) 
    {
        const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
        const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
        const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;

        fputc( TIXML_UTF_LEAD_0, fp );
        fputc( TIXML_UTF_LEAD_1, fp );
        fputc( TIXML_UTF_LEAD_2, fp );
    }
    //然后调用Print进行格式化输出
    Print( fp, 0 );
    return (ferror(fp) == 0);
}

接下来是我们用于输出的Print函数:

void TiXmlDocument::Print( FILE* cfile, int depth ) const
{
    assert( cfile );
    for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
    {
        //使用虚函数继承的方式,调用相应的处理函数
        node->Print( cfile, depth );
        fprintf( cfile, "\n" );
    }
}

这里用到了多态的方式,来实现相应的函数调用.

而生成所有xml树的方法Parse也是想同的想法.

 这里就只列举了TiXmlDocument和TiXmlElement的方法.其他的都是类似的处理方式.

//在TiXmlDocument::Parse中调用,用于判断接下来数据p中是什么类型的节点,并且生成该类型的节点返回
TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding )
{
    TiXmlNode* returnNode = 0;

    p = SkipWhiteSpace( p, encoding );
    //跳过空格后应该是'<',否则要么出错要么结束,返回null
    if( !p || !*p || *p != '<' )
    {
        return 0;
    }

    p = SkipWhiteSpace( p, encoding );

    if ( !p || !*p )
    {
        return 0;
    }

    
    
    const char* xmlHeader = { "<?xml" };
    const char* commentHeader = { "<!--" };
    const char* dtdHeader = { "<!" };
    const char* cdataHeader = { "<![CDATA[" };

    //分别判断接下来是什么
    //<?xml 代表是xml文件的declaration
    if ( StringEqual( p, xmlHeader, true, encoding ) )
    {
        #ifdef DEBUG_PARSER
            TIXML_LOG( "XML parsing Declaration\n" );
        #endif
        returnNode = new TiXmlDeclaration();
    }
    else if ( StringEqual( p, commentHeader, false, encoding ) )
    {//<!--代表是注释
        #ifdef DEBUG_PARSER
            TIXML_LOG( "XML parsing Comment\n" );
        #endif
        returnNode = new TiXmlComment();
    }
    else if ( StringEqual( p, cdataHeader, false, encoding ) )
    {//<![CDATA代表CDATA的数据,不过xml并没有相应去解析,仅仅做为文字处理
        #ifdef DEBUG_PARSER
            TIXML_LOG( "XML parsing CDATA\n" );
        #endif
        TiXmlText* text = new TiXmlText( "" );
        text->SetCDATA( true );
        returnNode = text;
    }
    else if ( StringEqual( p, dtdHeader, false, encoding ) )
    {//<!代表是dtd,不过由于不支持,所以返回为unknown
        #ifdef DEBUG_PARSER
            TIXML_LOG( "XML parsing Unknown(1)\n" );
        #endif
        returnNode = new TiXmlUnknown();
    }
    else if (    IsAlpha( *(p+1), encoding )
              || *(p+1) == '_' )
    {//如果是字符,则说明为element
        #ifdef DEBUG_PARSER
            TIXML_LOG( "XML parsing Element\n" );
        #endif
        returnNode = new TiXmlElement( "" );
    }
    else
    {//否则就是unknown
        #ifdef DEBUG_PARSER
            TIXML_LOG( "XML parsing Unknown(2)\n" );
        #endif
        returnNode = new TiXmlUnknown();
    }

    if ( returnNode )
    {
        // Set the parent, so it can report errors
        returnNode->parent = this;
    }
    return returnNode;
}

//TiXmlDocument的Parse,在LoadFile时被调用
const char* TiXmlDocument::Parse( const char* p, TiXmlParsingData* prevData, TiXmlEncoding encoding )
{
    ClearError();

    if ( !p || !*p )
    {
        SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );
        return 0;
    }

    location.Clear();
    if ( prevData )
    {
        location.row = prevData->cursor.row;
        location.col = prevData->cursor.col;
    }
    else
    {
        location.row = 0;
        location.col = 0;
    }
    //构造parsing data,用于记录数据的位置
    TiXmlParsingData data( p, TabSize(), location.row, location.col );
    location = data.Cursor();

    if ( encoding == TIXML_ENCODING_UNKNOWN )
    {
        // 判断是否是utf8 bom格式
        const unsigned char* pU = (const unsigned char*)p;
        if (    *(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0
             && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1
             && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2 )
        {
            encoding = TIXML_ENCODING_UTF8;
            useMicrosoftBOM = true;
        }
    }
    
    //跳过所有的空格符,包括\n\r\t ' '等.直接使用english的方式.在utf8情况下也很正常.
    p = SkipWhiteSpace( p, encoding );
    if ( !p )
    {
        SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );
        return 0;
    }

    while ( p && *p )
    {
        //利用Identify的方法来判断是某种元素,并且使用该种元素进行解析接下来的数据.
        TiXmlNode* node = Identify( p, encoding );
        if ( node )
        {
            p = node->Parse( p, &data, encoding );
            //将节点链接到最后的子节点之后.
            //LinkEndChild将节点的所有权直接改到父节点.减少一次复制
            LinkEndChild( node );
        }
        else
        {
            break;
        }

        // Did we get encoding info?
        if (    encoding == TIXML_ENCODING_UNKNOWN
             && node->ToDeclaration() )
        {
            TiXmlDeclaration* dec = node->ToDeclaration();
            const char* enc = dec->Encoding();
            assert( enc );

            if ( *enc == 0 )
                encoding = TIXML_ENCODING_UTF8;
            else if ( StringEqual( enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN ) )
                encoding = TIXML_ENCODING_UTF8;
            else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) )
                encoding = TIXML_ENCODING_UTF8;    // incorrect, but be nice
            else 
                encoding = TIXML_ENCODING_LEGACY;
        }

        p = SkipWhiteSpace( p, encoding );
    }

    // Was this empty?
    if ( !firstChild ) {
        SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, encoding );
        return 0;
    }

    return p;
}

//TiXmlElement::Parse,在TiXmlDocument中,检测到是element节点后被调用
//p代表读取的文本数据
const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
{
    p = SkipWhiteSpace( p, encoding );
    TiXmlDocument* document = GetDocument();

    //读取element时不应该出现结束的情况,返回错误
    if ( !p || !*p )
    {
        if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, 0, 0, encoding );
        return 0;
    }

    if ( data )
    {
        //计算目前处理的字符所在的位置
        //会有一定的性能影响.可以选择关闭
        data->Stamp( p, encoding );
        location = data->Cursor();
    }

    //这个应该不会遇到
    if ( *p != '<' )
    {
        if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, p, data, encoding );
        return 0;
    }

    p = SkipWhiteSpace( p+1, encoding );

    //获取节点的名字
    const char* pErr = p;

    //TiXMlElement的工具函数，读取tag的name
    p = ReadName( p, &value, encoding );
    if ( !p || !*p )
    {
        if ( document )    document->SetError( TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME, pErr, data, encoding );
        return 0;
    }

    //构造结尾标识符
    TIXML_STRING endTag ("</");
    endTag += value;

    // 获取element中的属性,结尾标识符
    while ( p && *p )
    {
        pErr = p;
        p = SkipWhiteSpace( p, encoding );
        if ( !p || !*p )
        {
            if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding );
            return 0;
        }
        if ( *p == '/' )
        {
            ++p;
            // 是空的tag,不具有子节点, <xxx   />
            if ( *p  != '>' )
            {
                if ( document ) document->SetError( TIXML_ERROR_PARSING_EMPTY, p, data, encoding );        
                return 0;
            }
            return (p+1);
        }
        else if ( *p == '>' )
        {
            // 处理完属性,下一步处理子节点
            ++p;
            //ReadValue会处理<x> </x>之间内的所有数据,包括文字,子节点.处理结束后返回
            p = ReadValue( p, data, encoding );        
            if ( !p || !*p ) {
                //到结尾了，这不应该发生
                if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );
                return 0;
            }

            if ( StringEqual( p, endTag.c_str(), false, encoding ) )
            {
                p += endTag.length();
                p = SkipWhiteSpace( p, encoding );
                if ( p && *p && *p == '>' ) {
                    ++p;
                    return p;
                }
                if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );
                return 0;
            }
            else
            {
                if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );
                return 0;
            }
        }
        else
        {
            // 是属性,进行处理
            //生成一个属性节点，然后调用该节点parse接下来的数据
            TiXmlAttribute* attrib = new TiXmlAttribute();
            if ( !attrib )
            {
                return 0;
            }

            attrib->SetDocument( document );
            pErr = p;
            p = attrib->Parse( p, data, encoding );

            if ( !p || !*p )
            {
                if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, pErr, data, encoding );
                delete attrib;
                return 0;
            }

            // 重复属性,直接报错,返回
            #ifdef TIXML_USE_STL
            TiXmlAttribute* node = attributeSet.Find( attrib->NameTStr() );
            #else
            TiXmlAttribute* node = attributeSet.Find( attrib->Name() );
            #endif
            if ( node )
            {
                if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, pErr, data, encoding );
                delete attrib;
                return 0;
            }

            //将该节点加入到attributeset中.
            attributeSet.Add( attrib );
        }
    }
    return p;
}

后语:

　　关于tinyxml的介绍大致到这里了.本文介绍了tinyxml的整体处理流程以及其实现的一些细节.之前也有读者提示说tinyxml很慢.而慢的原因有很多,一个是其用了很多多态,而多态是有一定的代价的.另外,其整体实现都是以树的方式完成的,包括element的属性是以链表的方式实现的,查找等效率都比较低下.