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的屬性是以鏈表的方式實現的,查找等效率都比較低下.