开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
QXmlParser.c
资源名称：ST_5105DTV.rar　[点击查看]
上传用户：fy98168
上传日期：2015-06-26
资源大小：13771k
文件大小：18k
源码类别：

DVD

开发平台：

C/C++

QXmlParser.c：源码内容
  1. #include <assert.h>
  3. #include <stdlib.h>
  5. #include <string.h>
  6. #include <ctype.h>
  7. #include <unistd.h>
  9. #include "QXmlParser.h"
  10. #include "XmlStbInfo.h" 
  12. char *xmlHeader = "<?xml";
  13. char *commentHeader = "<!--";
  14. char *commentEnd = "-->";
  15. char *cdataHeader = "<![CDATA[";
  16. char *cdataEnd = "]]>";
  20. QXmlEntity entity[] = 
  21. {
  22.    {"&amp;",  '&' },
  23.    {"&lt;",   '<' },
  24.    {"&gt;",   '>' },
  25.    {"&quot;", '"' },
  26.    {"&apos;", ''' }
  27. };
  29. QXmlParser   NewQXmlParser()
  30. {
  31.    QXmlParser self;
  33.    self.Parse = QXmlParserParse;
  34.    self.Worker = QXmlParserWorker;
  35.    self.FromFile = QXmlParserFromFile;
  36.    self.FromBuff = QXmlParserFromBuff;
  37.    self.ParseDeclaration = QXmlParserDeclaration;
  38.    self.ParseCommentText = QXmlParserCommentText;
  39.    self.ParseNode = QXmlParserNode;
  40.    self.ParseAttrib = QXmlParserAttrib;
  41.    self.ReadName = QXmlParserReadName;
  42.    self.ReadValue = QXmlParserReadValue;
  43.    self.ReadText = QXmlParserReadText;
  44.    self.GetEntity = QXmlParserGetEntity;
  45.    self.Release = QXmlParserRelease;
  47.    self.xml = NULL;
  48.    self.m_ioXML = NewQXmlIO();
  49.    self.m_nodeCurr = NULL;
  50.    return self;
  51. }
  53. QXmlParser   *MallocQXmlParser()
  54. {
  55.    QXmlParser *self = (QXmlParser *)KB_OSPMalloc(sizeof(QXmlParser));
  56.    if(!self) return NULL;
  58.    self->Parse = QXmlParserParse;
  59.    self->Worker = QXmlParserWorker;
  60.    self->FromFile = QXmlParserFromFile;
  61.    self->FromBuff = QXmlParserFromBuff;
  62.    self->ParseDeclaration = QXmlParserDeclaration;
  63.    self->ParseCommentText = QXmlParserCommentText;
  64.    self->ParseNode = QXmlParserNode;
  65.    self->ParseAttrib = QXmlParserAttrib;
  66.    self->ReadName = QXmlParserReadName;
  67.    self->ReadValue = QXmlParserReadValue;
  68.    self->ReadText = QXmlParserReadText;
  69.    self->GetEntity = QXmlParserGetEntity;
  70.    self->Release = QXmlParserRelease;
  72.    self->xml = NULL;
  73.    self->m_ioXML = NewQXmlIO();
  74.    self->m_nodeCurr = NULL;
  75.    return self;
  76. }
  78. int      QXmlParserParse (QXmlParser *self,QXml *xml)
  79. {
  80.    QXmlNode *node ;//= MallocQXmlNode();
  82.    assert(self);
  83.    assert(xml);
  84.    
  85.    self->xml = xml;
  87.    self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  88.    if ( self->m_ioXML.IsEmpty(&self->m_ioXML) )
  89.    {
  90.       xml->m_nErrorCode = XML_DATA_EMPTY;
  91.       return XML_DATA_EMPTY;
  92.    }
  93.    self->m_nodeCurr = xml->m_nodeRoot;
  95.    while ( !self->m_ioXML.IsEmpty(&self->m_ioXML) )
  96.    {
  97.       self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  98.       //执行解析工作
  99.       if(self->Worker(self) != XML_OK ) 
  100.       {
  101.          self->xml->m_nCol = self->m_ioXML.m_nCol;
  102.          self->xml->m_nRow = self->m_ioXML.m_nRow;
  103.          break;
  104.       }else
  105.       {
  106.          if(self->m_nodeCurr->m_nType != DECLARE && 
  107.          !self->m_nodeCurr->m_szName.IsEmpty(&self->m_nodeCurr->m_szName))
  108.          {
  109.             node = MallocQXmlNode();
  110.             if(node == NULL)
  111.             {
  112.                self->xml->m_nErrorCode =  XML_OUT_MEMORY;
  113.                break;
  114.             }
  115.             node->m_nodeParent = self->m_nodeCurr->m_nodeParent;
  116.             node->m_nodePrev = self->m_nodeCurr;
  117.             self->m_nodeCurr->m_nodeNext = node;
  118.             self->m_nodeCurr = node;
  119.          }
  120.  
  121.       }
  122.    }
  123.    if ( xml->m_nErrorCode == XML_OK)
  124.    {
  125.       if(self->m_nodeCurr->m_nodePrev) 
  126.  self->m_nodeCurr->m_nodePrev->m_nodeNext = NULL;
  128.       self->m_nodeCurr->Release(self->m_nodeCurr);
  129.       KB_OSPFree(self->m_nodeCurr);
  130.       self->m_nodeCurr = NULL;
  131.    }
  133.    return xml->m_nErrorCode;
  134. }
  135. int      QXmlParserWorker (QXmlParser *self)
  136. {
  137.    QString szHeader = NewQString();
  138.    assert(self);
  140.    szHeader.AllocBuffer(&szHeader,5);
  142.    szHeader.m_nDataLength = self->m_ioXML.GetBuff(&self->m_ioXML,
  143.                               szHeader.m_dataBuff,
  144.                               5);
  146.    if(strncmp(szHeader.m_dataBuff,
  147.          xmlHeader,
  148.          strlen(xmlHeader)) == 0)
  149.    {
  150.       //解析XML宣告
  151.       self->ParseDeclaration(self);
  152.    }else if (strncmp(szHeader.m_dataBuff,
  153.          commentHeader,
  154.          strlen(commentHeader)) == 0)
  155.    {
  156.       //解析一个注释   
  157.       self->ParseCommentText(self);
  158.    }else if ( isalpha( *(szHeader.m_dataBuff+1) ) || 
  159.       *(szHeader.m_dataBuff+1) == '_' )
  160.    {
  161.       //解析一个节点
  162.       self->ParseNode(self);
  163.    }else
  164.    {
  165.       if(!self->m_ioXML.IsEmpty(&self->m_ioXML))
  166.       {
  167.          //出现了不认识的部分,应该出错
  168.          self->xml->m_nErrorCode = XML_UNKNOW_FORMAT;
  169.       }
  170.       
  171.    }
  172.    //TODO: :) 加入解析头部为 <? 的'处理'类型
  174.    szHeader.Release(&szHeader);
  175.    return self->xml->m_nErrorCode;
  176. }
  179. int      QXmlParserFromFile (QXmlParser *self,int fd)
  180. {
  181.    self->m_ioXML.FromFile(&self->m_ioXML,fd);
  182.    return XML_OK;
  184. }
  185. int      QXmlParserFromBuff (QXmlParser *self,char *buff)
  186. {
  187.    assert(self);
  188.    if(buff == NULL) return XML_DATA_EMPTY;
  189.    self->m_ioXML.FromBuff(&self->m_ioXML,buff);
  190.    return XML_OK;
  191. }
  193. void   QXmlParserDeclaration (QXmlParser *self)
  194. {
  195.    QField *field;
  196.    QString szHeader = NewQString();
  198.    szHeader.AllocBuffer(&szHeader,2);
  200.    assert(self);
  201.    self->m_nodeCurr->m_nType = DECLARE;
  203.    self->m_ioXML.SkipChar(&self->m_ioXML, 5);
  204.    
  205.    if(self->m_ioXML.IsEmpty(&self->m_ioXML))
  206.    {
  207.       self->xml->m_nErrorCode = XML_DECLARE_ERROR;
  208.       szHeader.Release(&szHeader);
  209.       return ;
  210.    }
  212.    while ( !self->m_ioXML.IsEmpty(&self->m_ioXML))
  213.    {
  214.       self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  215.       
  216.       szHeader.m_nDataLength = self->m_ioXML.GetBuff(&self->m_ioXML,szHeader.m_dataBuff,2);
  218.       if(self->m_ioXML.IsEmpty(&self->m_ioXML)) 
  219.       {
  220.          self->xml->m_nErrorCode = XML_DECLARE_ERROR;
  221.          szHeader.Release(&szHeader);
  222.          return ;   
  223.       }
  225.       if(szHeader.Equal(&szHeader,"?>"))
  226.       {
  227.          self->m_ioXML.SkipChar(&self->m_ioXML, 2);
  228.          szHeader.Release(&szHeader);
  229.          return ;
  230.       }
  231.       
  232.       field = self->ParseAttrib(self);
  233.       if(field)
  234.       {
  235.          //接受任意的字段
  236.          printf("[%s]:[%s]n",field->name.m_dataBuff,field->value.m_dataBuff);
  237.          self->xml->m_listDeclare.m_listField.Add(&self->xml->m_listDeclare.m_listField,
  238.             field);
  239.       }else
  240.       {
  241.          if(self->xml->m_nErrorCode != XML_OK)
  242.          {
  243.             // 解析属性时出错
  244.             break;
  245.          }
  246.       }
  247.    }
  248.    szHeader.Release(&szHeader);
  249. }
  251. void   QXmlParserCommentText (QXmlParser *self)
  252. {
  253.    QXmlNode *node ;//= MallocQXmlNode();
  254.    int endlen = strlen(commentHeader);
  255.    node = self->m_nodeCurr;
  256.    
  257.    assert(self);
  258.    assert(node);
  260.    self->m_ioXML.SkipChar(&self->m_ioXML,strlen(commentHeader));
  262.    node->m_nType = COMMENT;
  264.    if(self->ReadValue(self,&node->m_szName,commentEnd,TRUE) != XML_OK)
  265.    {
  266.       self->xml->m_nErrorCode = XML_COMMENT_ERROR;
  267.    }
  268.    else
  269.    {
  270.       self->m_ioXML.SkipChar(&self->m_ioXML,endlen);
  271.       //printf("注释:[%s]n",node->m_szName->m_dataBuff);
  273.    }
  274. }
  276. void   QXmlParserNode (QXmlParser *self)
  277. {
  278.    
  279.    QXmlNode *node = NULL;
  280.    QString endTag ;
  281.    QString szHeader;
  282.    QField *field;
  283.    void        *pStbInfo=NULL;
  284.    KB_DC_TYPE  DcType = DC_TYPE_MAX;
  285.    char c;
  286.    
  287.    assert(self);
  288.    
  289.    self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  291.    self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);
  293.    if(c != '<')
  294.    {
  295.       self->xml->m_nErrorCode = XML_NODE_START_ERROR;
  296.       return ; 
  297.    }
  299.    self->m_ioXML.SkipChar(&self->m_ioXML,1);
  301.    node = self->m_nodeCurr;
  303.    node->m_nType = NODE;
  304.    
  305.    if(!node)
  306.    {
  307.       self->xml->m_nErrorCode = XML_OUT_MEMORY;
  308.       return; 
  309.    }
  310.    if(self->ReadName(self,&node->m_szName) != XML_OK)
  311.    {
  312.       return;
  313.    }
  315.    //printf("字段[%s]n",node->m_szName.m_dataBuff);
  316.    //added by whale 07/06/13
  317.    pStbInfo = LinkNewXmlInfoNode(node->m_szName.m_dataBuff, &DcType);
  319.    endTag = NewQString();
  320.    
  321.    endTag.AppendString(&endTag,"</");
  322.    endTag.AppendString(&endTag,node->m_szName.m_dataBuff);
  323.    endTag.AppendString(&endTag,">");
  324.    
  325.    self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  326.    // 读出属性.并检查是不是一个空的节点.或是结束的节点  
  327.    szHeader = NewQString();
  328.    
  329.    szHeader.AllocBuffer(&szHeader,endTag.m_nDataLength);
  330.    
  331.    self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);
  333.    while(!self->m_ioXML.IsEmpty(&self->m_ioXML))
  334.    {
  335.       self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  336.       
  337.       if ( self->m_ioXML.IsEmpty(&self->m_ioXML) )
  338.       {
  339.          self->xml->m_nErrorCode = XML_DATA_EMPTY;         
  340.          endTag.Release(&endTag);
  341.          szHeader.Release(&szHeader);
  342.          return ;    
  343.       }
  344.       if ( c == '/' )
  345.       {
  346.          self->m_ioXML.SkipChar(&self->m_ioXML,1);
  347.          self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);
  348.          if ( c  != '>')
  349.          {
  350.             // 不允许出现 '/ >' 这样的结尾节点  
  351.             self->xml->m_nErrorCode = XML_NODE_END_ERROR;
  352.             endTag.Release(&endTag);
  353.             szHeader.Release(&szHeader);
  354.             return ;
  355.          }
  356.          self->m_ioXML.SkipChar(&self->m_ioXML,1);
  357.          endTag.Release(&endTag);
  358.          szHeader.Release(&szHeader);
  359.          //printf("NODE[%s]n",node->m_szName.m_dataBuff);
  360.    
  361.          return ;         
  362.       }
  363.       else if ( c == '>' )
  364.       {   
  365.          // 节点的属性读完(无属性),并且有节点的值,或有子节点. 
  366.          self->m_ioXML.SkipChar(&self->m_ioXML,1);
  367.          if(self->ReadText(self,&node->m_szValue) != XML_OK)
  368.          {
  369.             endTag.Release(&endTag);
  370.             szHeader.Release(&szHeader);
  371.             return ;
  372.          }
  373.          // 去掉 </TAG>这样的结尾
  374.          self->m_ioXML.SkipChar(&self->m_ioXML,endTag.m_nDataLength);
  375.          endTag.Release(&endTag);
  376.          szHeader.Release(&szHeader);
  377.          break;
  378.       }
  379.       else
  380.       {
  381.          // 这里是解析属性的
  382.          
  383.          field = self->ParseAttrib(self);
  384.          if(field)
  385.   {
  386. //added by whale 07/06/13
  387. AddXmlNodeValue(field->name.m_dataBuff, field->value.m_dataBuff, pStbInfo, DcType);
  388.             //printf("[%s]:[%s]n",field->name.m_dataBuff,field->value.m_dataBuff);
  389.             node->SetAttrib(node,field->name.m_dataBuff,field->value.m_dataBuff);
  390.             field->Release(field);
  391. KB_OSPFree(field);
  392.             field = NULL;
  393.          }
  394.  else
  395.          {
  396.             if(self->xml->m_nErrorCode != XML_OK)
  397.             {
  398.                // 解析属性时出错
  399.                break;
  400.             }
  401.          }
  403.       }
  404.        self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);
  406.    }
  407.    endTag.Release(&endTag);
  408.    szHeader.Release(&szHeader);
  409.    //printf("NODE[%s]n",node->m_szName.m_dataBuff);
  410. }
  411. //解析属性
  412.  
  413. QField   *QXmlParserAttrib (QXmlParser *self)
  414. {
  415.    QField *field;
  416.    QString  endText;
  417.    char c;
  418.    assert(self);
  421.    if((field = MallocQField()) == NULL)
  422.    {
  423.       self->xml->m_nErrorCode = XML_OUT_MEMORY;
  424.       return NULL;
  425.    }
  426.    if(self->ReadName(self,&(field->name)) == XML_OK)
  427.    {
  428.       self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  429.       //根据 '='得到得到单引号或双引号
  430.       self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);   
  431.       if(c != '=' || self->m_ioXML.IsEmpty(&self->m_ioXML))
  432.       {
  433.          self->xml->m_nErrorCode = XML_ATTRIB_ERROR;   
  434.          field->Release(field);
  435.          KB_OSPFree(field);
  436.          return NULL;
  437.       }
  439.       self->m_ioXML.SkipChar(&self->m_ioXML,1);
  440.       self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  441.       
  442.       endText = NewQString();
  444.       self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);   
  445.       if ( c == ''' )
  446.       {
  447.          endText.AppendString(&endText,"'");
  448.       }else if ( c == '"')
  449.       {
  450.          endText.AppendString(&endText,""");
  451.       }else
  452.       {
  453.          // 没有引号 
  454.          self->xml->m_nErrorCode = XML_NO_QUOTA;
  455.          endText.Release(&endText);
  457.          return NULL;
  458.       }
  460.       self->m_ioXML.SkipChar(&self->m_ioXML,1);
  462.       if(self->ReadValue(self,
  463.          &(field->value),
  464.          endText.m_dataBuff,
  465.          TRUE) != XML_OK)
  466.       {
  467.          field->Release(field);
  468.          KB_OSPFree(field);
  469.          field = NULL;
  470.       }
  471.       self->m_ioXML.SkipChar(&self->m_ioXML,endText.m_nDataLength);
  473.       endText.Release(&endText);
  474.       return field;
  475.    }
  476.    return NULL;   
  477. }
  479. int      QXmlParserReadName (QXmlParser *self , QString *Name)
  480. {
  481.    char c;
  482.    assert(self);
  484.    self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  486.    // 读出一个字段名.或一个属性名 
  487.    
  488.    self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);
  490.    if ( !self->m_ioXML.IsEmpty(&self->m_ioXML) &&
  491.       ( isalpha( c ) || c == '_') )
  492.    {
  493.       while(   !self->m_ioXML.IsEmpty(&self->m_ioXML)
  494.          &&   (isalnum( c ) 
  495.          || c == '_'
  496.          || c == '-'
  497.          || c == '.'
  498.          || c == ':')){
  499.          Name->AppendChar(Name,c);
  500.          self->m_ioXML.SkipChar(&self->m_ioXML,1);
  501.          self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);      
  502.       }
  503.    }
  504.    return XML_OK;
  505. }
  507. int      QXmlParserReadValue (QXmlParser *self ,                   
  508.                   QString *Value,
  509.                   char *endTag, //以什么结束
  510.                   BOOL conv )   //是否进行 '&' 的转换
  512. {
  513.    char c;
  514.    int endlen = 0;
  516.    QString szHeader;
  517.    QString szConvHeader;
  519.    assert(self);
  520.    if(endTag == NULL)
  521.    {
  522.       self->xml->m_nErrorCode = XML_DATA_EMPTY;
  523.       return self->xml->m_nErrorCode ;
  524.    }
  526.    endlen = strlen(endTag);
  529.    self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  532.    self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);   
  534.    szHeader = NewQString();
  535.    szConvHeader = NewQString();
  537.    szHeader.AllocBuffer(&szHeader,endlen);
  539.    while( !self->m_ioXML.IsEmpty(&self->m_ioXML))
  540.    {
  541.       
  542.       szHeader.m_nDataLength = self->m_ioXML.GetBuff(&self->m_ioXML,
  543.          szHeader.m_dataBuff,
  544.          endlen);
  546.       if(szHeader.Equal(&szHeader,endTag))
  547.       {
  548.          //读取结束
  549.          break;
  550.       }
  551.       else
  552.       {
  553.          if(c == '&' && conv)// 需要进行特殊字符转义            
  554.          {
  555.             char tempConv;
  556.             szConvHeader.Release(&szConvHeader);
  557.             while(c != ';' && szConvHeader.m_nDataLength <= 6)
  558.             {
  559.                szHeader.AppendChar(&szConvHeader,c);
  560.                self->m_ioXML.SkipChar(&self->m_ioXML,1);
  561.                self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);   
  562.             }
  563.             
  564.             szConvHeader.AppendChar(&szConvHeader,c);
  565.             
  566.             self->m_ioXML.SkipChar(&self->m_ioXML,1);
  567.             
  568.             tempConv = self->GetEntity(self,szConvHeader.m_dataBuff);
  570.             if(tempConv != '')
  571.                Value->AppendChar(Value,tempConv);   
  572.             else
  573.                Value->AppendString(Value,szConvHeader.m_dataBuff);   
  575.             szConvHeader.Release(&szConvHeader);
  576.          }
  577.          else
  578.          {
  579.             Value->AppendChar(Value,c);   
  580.             self->m_ioXML.SkipChar(&self->m_ioXML,1);
  581.          }
  582.       }
  583.       self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);
  584.    }
  585.    szHeader.Release(&szHeader);
  586.    
  587.    return self->xml->m_nErrorCode;
  588. }
  590. int      QXmlParserReadText (QXmlParser *self , QString *Text)
  591. {
  592.    char c;
  593.    int endLen = strlen(cdataHeader);
  594.    QString szHeader ;
  595.    
  596.    assert(self);
  597.    
  598.    self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  599.    
  600.    szHeader = NewQString();
  602.    szHeader.AllocBuffer(&szHeader,endLen);
  604.    szHeader.m_nDataLength = self->m_ioXML.GetBuff(&self->m_ioXML,
  605.                               szHeader.m_dataBuff,
  606.                               endLen);
  608.    if(szHeader.Equal(&szHeader,cdataHeader))
  609.    {
  610.       //<![CDATA[ 除了]]> 其他所有的字符全部正常接收   
  611.       self->m_ioXML.SkipChar(&self->m_ioXML, endLen);
  613.       endLen = strlen(cdataEnd);
  614.       szHeader.Release(&szHeader);
  615.       szHeader.AllocBuffer(&szHeader,endLen);
  617.       self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);
  619.       while(!self->m_ioXML.IsEmpty(&self->m_ioXML))
  620.       {
  621.          self->m_ioXML.GetBuff(&self->m_ioXML,szHeader.m_dataBuff,endLen);
  622.          if(self->m_ioXML.IsEmpty(&self->m_ioXML))
  623.          {
  624.             szHeader.Release(&szHeader);
  625.             self->xml->m_nErrorCode = XML_NO_CDATA_END;
  626.             return self->xml->m_nErrorCode;
  627.          }
  628.       
  629.          if(szHeader.Equal(&szHeader,cdataEnd))
  630.          {
  631.             self->m_ioXML.SkipChar(&self->m_ioXML, endLen);
  632.             szHeader.Release(&szHeader);
  633.             self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  634.             break;
  635.          }
  637.          Text->AppendChar(Text,c);
  638.          self->m_ioXML.SkipChar(&self->m_ioXML, 1);
  639.          self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);
  640.       }      
  641.       self->m_nodeCurr->m_nType = HOLD;
  642.    }
  643.    szHeader.Release(&szHeader);
  644.    szHeader.AllocBuffer(&szHeader,2);
  647.    self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);
  649.    while ( !self->m_ioXML.IsEmpty(&self->m_ioXML) )
  650.    {
  651.       self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  653.       self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);
  655.       if ( c != '<' )
  656.       {
  657.          // 如果有值的话.先解析值 
  659.          if(self->ReadValue(self,Text,"<",TRUE) != XML_OK)
  660.          {
  661.             szHeader.Release(&szHeader);
  662.             return self->xml->m_nErrorCode;
  663.          }
  664.          else
  665.          {            
  666.             self->m_ioXML.GetBuff(&self->m_ioXML,&c,1);
  667.          //   printf("值[%s]n",Text->m_dataBuff);   
  668.             continue;
  669.          }
  670.       } 
  671.       else 
  672.       {
  673.          // 检查是否还有子节点 
  674.          szHeader.m_nDataLength = self->m_ioXML.GetBuff(&self->m_ioXML,
  675.                               szHeader.m_dataBuff,
  676.                               2);      
  677.          if ( szHeader.Equal(&szHeader, "</") )
  678.          {
  679.             szHeader.Release(&szHeader);
  680.             return XML_OK;
  681.          }
  682.          else
  683.          {
  684.             QXmlNode *node  = MallocQXmlNode();         
  685.             QXmlNode *nodeParent;         
  686.             
  687.             if(!node)
  688.             {
  689.                self->xml->m_nErrorCode = XML_OUT_MEMORY;
  690.                szHeader.Release(&szHeader);
  691.                return self->xml->m_nErrorCode; 
  692.             }
  693.             node->m_nodeParent = self->m_nodeCurr;
  694.             
  695.             nodeParent = node->m_nodeParent;
  697.             self->m_nodeCurr->AddNodeToChild(self->m_nodeCurr,node);
  698.             self->m_nodeCurr = node;
  700.             self->m_ioXML.SkipWhiteSpace(&self->m_ioXML);
  701.             
  702.             if(self->Worker(self) != XML_OK)
  703.             {
  704.                szHeader.Release(&szHeader);
  705.                return self->xml->m_nErrorCode;
  706.             }
  707.             else
  708.             {
  709.                self->m_nodeCurr = nodeParent;   
  710.                continue;
  711.             }
  712.          }
  713.       }
  715.    }
  717.    self->xml->m_nErrorCode = XML_READ_NODE_VALUE;
  718.    szHeader.Release(&szHeader);
  719.    return self->xml->m_nErrorCode;
  720. }
  723. char    QXmlParserGetEntity(QXmlParser *self , char * p)
  724. {
  725.    int i ;
  726.    for( i=0; i<sizeof(entity)/8; i++ )
  727.    {
  728.       if(strcmp(entity[i].str,p) == 0)
  729.       {
  730.          return entity[i].chr;
  731.       }
  732.    }
  733.    return '';
  735. }
  736. void   QXmlParserRelease ( QXmlParser *self)
  737. {
  738.    assert(self);
  739.    self->m_ioXML.Release(&self->m_ioXML);   
  740. }