tinyxml2源码分析-3

最新推荐文章于 2023-05-12 16:09:43 发布
最新推荐文章于 2023-05-12 16:09:43 发布
阅读量991 收藏 1
点赞数 1
分类专栏： tinyxml2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiukongjian/article/details/52674658
版权

在开始编写读取文件时，先简单介绍下解析策略，对于xml文件：

<?This is a Declaration!?>
<!--This is a Document Comment!-->
<School>
    <!--This is a School Comment!-->
    <teachers>
        <Wang/>
        <Li/>
        <Zhao/>
    </teachers>
    <students>
        <LiMing sex="male" height="174" weight="80.400000000000006" Is_good_at_math="false">Li Ming is a good Student!</LiMing>
        <CuiHua>this is a Text!</CuiHua>
        <Hanmeimei><![CDATA[this is a CData Text:if (a < b && a < 0)]]></Hanmeimei>
    </students>
    <!this is a Unknow!>
</School>

我们要建立的DOM树如下图所示，



不同节点的头是不同的，如下：

XMLDeclaration：<?
XMLComment： <!-- 
XMLText(CData)：<![CDATA[
XMLUnknown:<!
XMLElement:<

XMLText:剩下的

在解析时，把<xxx> ...</xxx>这样类型的Element，第一个<xxx>为父节点，最后一个</xxx>将是<xxx>的_lastChild，最后再删除</xxx>。

对于父节点，我们使用如下策略：

1)我们从头开始遍历文件，如果碰到 <?，创建XMLDeclaration，继续搜索?>，使用InsertEndChild插入;

2)如果碰到 <!-- ，创建XMLComment，继续搜索-->，使用InsertEndChild插入;

3)如果碰到<![CDATA[，创建XMLText，继续搜索]]>，使用InsertEndChild插入;

4)如果碰到 <!，创建XMLUnknown，继续搜索>，使用InsertEndChild插入;

5)如果碰到 <，创建XMLElemet，接着解析


if(/xxx>类型){

则标记状态为CLOSING,意味着某个Element结束了。使用InsertEndChild插入;并且和父类XMLElemet的名称做对比，相等则删除该XMLElement。

}

else{

使用InsertEndChild插入;解析Attributes，如果以/>结尾，该节点解析完毕。否则，将当前节点设为父节点，跳到1）开始解析它的子节点。

}

6)XMLText，搜索<，返回<之前的指针即可。

从上面的逻辑可以看出，需要递归解析，而每个节点类型的解析方式也不同，所以需要一个多态的解析接口，在XMLNode中增加解析接口ParseDeep(源代码的子类重载的时候并没有加virtual，不是个好习惯)，其实XMLNode的搜索，就是父节点的搜索策略:

 virtual char* ParseDeep( char*, StrPair* );

先定义搜索节点头函数：

char* XMLDocument::Identify( char* p, XMLNode** node )
{
    TIXMLASSERT( node );
    TIXMLASSERT( p );
    char* const start = p;
    p = XMLUtil::SkipWhiteSpace( p );
    if( !*p ) {
        *node = 0;
        TIXMLASSERT( p );
        return p;
    }

    // These strings define the matching patterns:
    static const char* xmlHeader		= { "<?" };
    static const char* commentHeader	= { "<!--" };
    static const char* cdataHeader		= { "<![CDATA[" };
    static const char* dtdHeader		= { "<!" };
    static const char* elementHeader	= { "<" };	// and a header for everything else; check last.

    static const int xmlHeaderLen		= 2;
    static const int commentHeaderLen	= 4;
    static const int cdataHeaderLen		= 9;
    static const int dtdHeaderLen		= 2;
    static const int elementHeaderLen	= 1;

    TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) );		// use same memory pool
    TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) );	// use same memory pool
    XMLNode* returnNode = 0;
    if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
        TIXMLASSERT( sizeof( XMLDeclaration ) == _commentPool.ItemSize() );
        returnNode = new (_commentPool.Alloc()) XMLDeclaration( this );
        returnNode->_memPool = &_commentPool;
        p += xmlHeaderLen;
    }
    else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
        TIXMLASSERT( sizeof( XMLComment ) == _commentPool.ItemSize() );
        returnNode = new (_commentPool.Alloc()) XMLComment( this );
        returnNode->_memPool = &_commentPool;
        p += commentHeaderLen;
    }
    else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
        TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );
        XMLText* text = new (_textPool.Alloc()) XMLText( this );
        returnNode = text;
        returnNode->_memPool = &_textPool;
        p += cdataHeaderLen;
        text->SetCData( true );
    }
    else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
        TIXMLASSERT( sizeof( XMLUnknown ) == _commentPool.ItemSize() );
        returnNode = new (_commentPool.Alloc()) XMLUnknown( this );
        returnNode->_memPool = &_commentPool;
        p += dtdHeaderLen;
    }
    else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
        TIXMLASSERT( sizeof( XMLElement ) == _elementPool.ItemSize() );
        returnNode = new (_elementPool.Alloc()) XMLElement( this );
        returnNode->_memPool = &_elementPool;
        p += elementHeaderLen;
    }
    else {
        TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );
        returnNode = new (_textPool.Alloc()) XMLText( this );
        returnNode->_memPool = &_textPool;
        p = start;	// Back it up, all the text counts.
    }

    TIXMLASSERT( returnNode );
    TIXMLASSERT( p );
    *node = returnNode;
    return p;
}

下面看XMLNode的搜索，

char* XMLNode::ParseDeep( char* p, StrPair* parentEnd )
{
    while( p && *p ) {
        XMLNode* node = 0;

        p = _document->Identify( p, &node );//搜索节点头，根据节点头创建对应的子节点
        if ( node == 0 ) {
            break;
        }

        StrPair endTag;
        p = node->ParseDeep( p, &endTag );//由子节点根据自己的策略完成搜索
        if ( !p ) {
            DeleteNode( node );
            if ( !_document->Error() ) {
                _document->SetError( XML_ERROR_PARSING, 0, 0 );
            }
            break;
        }

        XMLDeclaration* decl = node->ToDeclaration();
        if ( decl ) {//如果有声明，必须是文档的第一个孩子
                // A declaration can only be the first child of a document.
                // Set error, if document already has children.
                if ( !_document->NoChildren() ) {
                        _document->SetError( XML_ERROR_PARSING_DECLARATION, decl->Value(), 0);
                        DeleteNode( node );
                        break;
                }
        }

        XMLElement* ele = node->ToElement();
        if ( ele ) {
            // 解析到</xxx>了，直接返回，当前Element的解析结束
            if ( ele->ClosingType() == XMLElement::CLOSING ) {
                if ( parentEnd ) {
                    ele->_value.TransferTo( parentEnd );
                }
                node->_memPool->SetTracked();   // created and then immediately deleted.
                DeleteNode( node );
                return p;
            }

            // Handle an end tag returned to this level.
            // And handle a bunch of annoying errors.
            bool mismatch = false;
            if ( endTag.Empty() ) {
                if ( ele->ClosingType() == XMLElement::OPEN ) {
                    mismatch = true;
                }
            }
            else {
                if ( ele->ClosingType() != XMLElement::OPEN ) {
                    mismatch = true;
                }//下面比较Element是否对应
                else if ( !XMLUtil::StringEqual( endTag.GetStr(), ele->Name() ) ) {
                    mismatch = true;
                }
            }
            if ( mismatch ) {
                _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, ele->Name(), 0 );
                DeleteNode( node );
                break;
            }
        }
        InsertEndChild( node );//插入子节点
    }
    return 0;
}

I

XMLText的搜索策略

// --------- XMLText ---------- //
char* XMLText::ParseDeep( char* p, StrPair* )
{
    const char* start = p;
    if ( this->CData() ) {
        p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
        if ( !p ) {
            _document->SetError( XML_ERROR_PARSING_CDATA, start, 0 );
        }
        return p;
    }
    else {
        int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;
        if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {
            flags |= StrPair::NEEDS_WHITESPACE_COLLAPSING;
        }

        p = _value.ParseText( p, "<", flags );
        if ( p && *p ) {
            return p-1;
        }
        if ( !p ) {
            _document->SetError( XML_ERROR_PARSING_TEXT, start, 0 );
        }
    }
    return 0;
}
XMLComment： 
char* XMLComment::ParseDeep( char* p, StrPair* )
{
    // Comment parses as text.
    const char* start = p;
    p = _value.ParseText( p, "-->", StrPair::COMMENT );
    if ( p == 0 ) {
        _document->SetError( XML_ERROR_PARSING_COMMENT, start, 0 );
    }
    return p;
}
XMLDeclaration： 

char* XMLDeclaration::ParseDeep( char* p, StrPair* )
{
    // Declaration parses as text.
    const char* start = p;
    p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
    if ( p == 0 ) {
        _document->SetError( XML_ERROR_PARSING_DECLARATION, start, 0 );
    }
    return p;
}

XMLUnknown：

char* XMLUnknown::ParseDeep( char* p, StrPair* )
{
    // Unknown parses as text.
    const char* start = p;

    p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION );
    if ( !p ) {
        _document->SetError( XML_ERROR_PARSING_UNKNOWN, start, 0 );
    }
    return p;
}

XMLElement：

char* XMLElement::ParseDeep( char* p, StrPair* strPair )
{
    // Read the element name.
    p = XMLUtil::SkipWhiteSpace( p );

    // The closing element is the </element> form. It is
    // parsed just like a regular element then deleted from
    // the DOM.
    if ( *p == '/' ) {
        _closingType = CLOSING;
        ++p;
    }

    p = _value.ParseName( p );
    if ( _value.Empty() ) {
        return 0;
    }

    p = ParseAttributes( p );
    if ( !p || !*p || _closingType ) {
        return p;
    }
<span style="white-space:pre">	</span>//调用XMLNode中的解析方法，就是将当前节点设为父节点，在这里实现递归调用
    p = XMLNode::ParseDeep( p, strPair );
    return p;
}
XMLDocument就使用XMLNode的策略，因为他是一个父节点。

可以开始编写LoadFile的代码了,XMLError是个枚举类型，一般而言，先定义一个枚举，同时定义XML_SUCCESS=0，因为成功不需要理由，失败者总是需要借口。等到编码到后期再添加错误码。

XMLError XMLDocument::LoadFile( const char* filename )
{
    Clear();
    FILE* fp = callfopen( filename, "rb" );
    if ( !fp ) {
        SetError( XML_ERROR_FILE_NOT_FOUND, filename, 0 );
        return _errorID;
    }
    LoadFile( fp );
    fclose( fp );
    return _errorID;
}

如果打开文件失败，返回XML_ERROR_FILE_NOT_FOUND错误。这时候可以在enum XMLError中添加错误码，以后为了不影响主要源码的阅读，不再细说。接着调用LoadFile

XMLError XMLDocument::LoadFile( FILE* fp )
{
    Clear();
    fseek( fp, 0, SEEK_SET );//如果文件内容为空，返回错误
    if ( fgetc( fp ) == EOF && ferror( fp ) != 0 ) {
        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
        return _errorID;
    }
    fseek( fp, 0, SEEK_END );
    const long filelength = ftell( fp );
    fseek( fp, 0, SEEK_SET );//文件长度错误时
    if ( filelength == -1L ) {
        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
        return _errorID;
    }
    TIXMLASSERT( filelength >= 0 );//检查size_t和unsigned long的字节个数是否相等
    if ( !LongFitsIntoSizeTMinusOne<>::Fits( filelength ) ) {
        // Cannot handle files which won't fit in buffer together with null terminator
        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
        return _errorID;
    }
    if ( filelength == 0 ) {
        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
        return _errorID;
    }

    const size_t size = filelength;
    TIXMLASSERT( _charBuffer == 0 );
    _charBuffer = new char[size+1];//知道了文件有多大，可以分配内存了
    size_t read = fread( _charBuffer, 1, size, fp );
    if ( read != size ) {
        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
        return _errorID;
    }

    _charBuffer[size] = 0;

    Parse();
    return _errorID;
}
开始解析文档，utf8 bom 自行搜索： 

void XMLDocument::Parse()
{
    TIXMLASSERT( NoChildren() ); // Clear() must have been called previously
    TIXMLASSERT( _charBuffer );
    char* p = _charBuffer;
    p = XMLUtil::SkipWhiteSpace( p );
    p = const_cast<char*>( XMLUtil::ReadBOM( p, &_writeBOM ) );
    if ( !*p ) {
        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
        return;
    }
    ParseDeep(p, 0 );
}




走调的鱼
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tinyxml2源码分析（一）
ml143的专栏
03-26 2231
tinyxml2源码分析（一）主要分析文本解析部分
tinyxml2源码及示例
10-13
3. **遍历XML结构**：使用TinyXML2，你可以轻松地遍历整个XML文档的元素层次。例如，可以使用`FirstChildElement()`和`NextSiblingElement()`方法来获取子元素和同级元素，或者使用`FirstChild()`和`FirstChildText...
TinyXML2源代码及工程
12-22
TinyXML2源代码及工程，读写轻便有效率，接口易使用
tinyxml2源码分析-1
09-25 1129
换一种方式来对源码分析，从零开始“写”一个tinyxml2。提前郑重声明，本博客所有大tinyxml代码都直接copy自tinyxml源码。 在开始分析源码前，如下图所示，是tinyxml2的各个主要类型，XMLAttribute其实是一个单向链表，放在后面实现。 tinyxml2把xml文档建立成一棵DOM树，具体实现用的是firstchild–nextsiblingtree，如
tinyxml2源码分析-2
09-25 1111
我们实现了XMLNode，接下来我们实现XMLText class XMLText : public XMLNode { friend class XMLDocument; public: virtual XMLText* ToText(){ return this; } virtual const XMLText* ToText() const{ return this;
C++ —— Tinyxml2在Vs2017下相关使用1（附源码）
wx微信公众号“码农总动员”，获取更多编程知识
05-12 341
TinyXML2是一个简单，小巧，高效，C++XML解析器，可以很容易地集成到其他程序中。TinyXML-2解析一个XML文档，并从中构建一个 可以读取、修改和保存的文档对象模型 （DOM）。XML代表“可扩展标记语言”。这是一个通用目的 用于描述任意数据的人类和机器可读标记语言。为存储应用程序数据而创建的所有随机文件格式都可以 全部替换为 XML。一个解析器可以解决所有问题。
tinyXml2源码
09-21
TinyXML2是一个小型、快速且易于使用的C++库，用于解析和操作XML文档。这个库的设计目标是简单、小巧，适合嵌入式系统或者任何需要轻量级XML处理的项目。 TinyXML2相较于其前身TinyXML，进行了许多优化，减少了内存...
Tinyxml解析源码
08-18
TinyXML的源码分析可以从以下几个方面入手： 1. **解析流程**：TinyXML通过`TiXmlDocument`类作为入口，加载XML文件。它首先读取文件内容，然后通过`TiXmlElement`类解析XML元素，`TiXmlAttribute`处理属性，`...
yolov4-tiny火焰检测源码
09-14
《YOLOv4-tiny火焰检测源码解析与应用》 YOLO（You Only Look Once）是一种基于深度学习的目标检测框架，因其实时性高、准确率优秀而广受青睐。YOLOv4-tiny是YOLO系列的一个轻量级版本，优化了计算效率，适合在资源...
tinyxml解析工具修复内存泄漏
05-06
这个tinyxml是在部门产品应用过程中发现存在内存泄漏的问题，通过代码分析，解决了在xml使用结束时，内存清理不彻底而导致的内存泄漏问题。电驴源码中使用的tinyxml也存在这个问题。不知最新版有没有修复。
tinyxml源代码，示例，教程
03-25
便宜，超全 快速入门 tinyxml源代码，示例，教程 三个包
tinyxml2解压可直接使用,不能用你@我
08-20
官方的tinyxml你下载下来是不能正常使用的,因为缺少stdint.h这个头文件.我这个压缩包里包含了有偿下载的stdint.h和inttypes.h两个头文件,所以收费高点(光是这两个头文件就不止4分了)
Excel表格转换成xml文件格式 C++源码
02-01
Excel表格信息按规定格式转换成xml方便项目开发时读取配置 C++源码
C++ 本地使用tinyxml2解析Xml文件
给大佬递杯卡布奇诺的博客
09-24 2324
c++ 移植tinyxml操作xml
嵌入式linux对xml文件的操作（expat篇）
gnnulzy的博客
02-28 2086
前段时间在项目中用到了涉及到了xml文件的解析，环境是嵌入式linux，在此简单总结一下留个记录，也跟大家分享一下。        我在项目中用的是expat解析库，还有很多其它的库可以使用，比如libxml、minixml等，它们之间有些差别，下面是从网上粘来的说法。        目前的xml解析器一般有两种解析的形式.一种是DOM模型的,一种是SAX2模型的.DOM模型是讲xml文件中的结构...
XML_ERROR_MISMATCHED_ELEMENT
Hill的专栏
10-18 558
Minio 启动后会有两个接口，一个是 API 接口，另一个是 HTTP 接口。在使用 Aws SDK C++ 调用 Minio 时，错误的使用了 HTTP 接口（应该使用 API 接口) , 导致一直提示错误 Xml Parse Error: XML_ERROR_MISMATCHED_ELEMENT 以此记录 ...
assert 配合#粘连符号调试程序
dadalan的专栏
08-16 442
 #include #include #define  mack(x) #xint main(int argc, char* argv[]){ assert(!mack(abc)); return 0;}
c++xml读取n工具_tinyxml
苏凯的博客
09-28 569
tinyxml2.cpp /* Original code by 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. Permi.
tinyxml2使用方法
09-25 4924
最近项目中使用到xml，最终选用了tinyxml2，学习后写个使用总结。
tinyxml2 源码分析
最新发布
06-03
下面是对 tinyxml2 源码的一些分析： 1. 文件结构 tinyxml2 的源码包括以下文件： - tinyxml2.h：包含 tinyxml2 的 API。 - tinyxml2.cpp：包含 tinyxml2 的实现代码。 - xmltest.cpp：包含 tinyxml2 的测试代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值