Make code compile with clang_use_chrome_plugin (final)

xfa/fde/xml/fde_xml_imp.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fde/xml/fde_xml_imp.h"
 
 #include <algorithm>
 
@@ skipping 62 matching lines @@
   }
   return FALSE;
 }
 
 CFDE_XMLNode::CFDE_XMLNode()
     : m_pParent(nullptr),
       m_pChild(nullptr),
       m_pPrior(nullptr),
       m_pNext(nullptr) {}
 
+void CFDE_XMLNode::Release() {
+  delete this;
+}
+
+FDE_XMLNODETYPE CFDE_XMLNode::GetType() const {
+  return FDE_XMLNODE_Unknown;
+}
+
 CFDE_XMLNode::~CFDE_XMLNode() {
   DeleteChildren();
 }
 
 void CFDE_XMLNode::DeleteChildren() {
   CFDE_XMLNode* pChild = m_pChild;
   while (pChild) {
     CFDE_XMLNode* pTemp = pChild->m_pNext;
     pChild->Release();
     pChild = pTemp;
   }
   m_pChild = nullptr;
 }
+
 int32_t CFDE_XMLNode::CountChildNodes() const {
   int32_t iCount = 0;
   CFDE_XMLNode* pChild = m_pChild;
   while (pChild) {
     iCount++;
     pChild = pChild->m_pNext;
   }
   return iCount;
 }
+
 CFDE_XMLNode* CFDE_XMLNode::GetChildNode(int32_t index) const {
   CFDE_XMLNode* pChild = m_pChild;
   while (pChild) {
     if (index == 0) {
       return pChild;
     }
     index--;
     pChild = pChild->m_pNext;
   }
   return nullptr;
 }
+
 int32_t CFDE_XMLNode::GetChildNodeIndex(CFDE_XMLNode* pNode) const {
   int32_t index = 0;
   CFDE_XMLNode* pChild = m_pChild;
   while (pChild) {
     if (pChild == pNode) {
       return index;
     }
     index++;
     pChild = pChild->m_pNext;
   }
   return -1;
 }
+
 CFDE_XMLNode* CFDE_XMLNode::GetPath(const FX_WCHAR* pPath,
                                     int32_t iLength,
                                     FX_BOOL bQualifiedName) const {
   ASSERT(pPath);
   if (iLength < 0) {
     iLength = FXSYS_wcslen(pPath);
   }
   if (iLength == 0) {
     return nullptr;
   }
@@ skipping 37 matching lines @@
             return pFind;
         }
       }
       pNode = pNode->m_pNext;
     }
   }
   if (!pFind || iLength < 1)
     return pFind;
   return pFind->GetPath(pStart, iLength, bQualifiedName);
 }
+
 int32_t CFDE_XMLNode::InsertChildNode(CFDE_XMLNode* pNode, int32_t index) {
   pNode->m_pParent = this;
   if (!m_pChild) {
     m_pChild = pNode;
     pNode->m_pPrior = nullptr;
     pNode->m_pNext = nullptr;
     return 0;
   }
   if (index == 0) {
     pNode->m_pNext = m_pChild;
     pNode->m_pPrior = nullptr;
     m_pChild->m_pPrior = pNode;
     m_pChild = pNode;
     return 0;
   }
   int32_t iCount = 0;
   CFDE_XMLNode* pFind = m_pChild;
   while (++iCount != index && pFind->m_pNext) {
     pFind = pFind->m_pNext;
   }
   pNode->m_pPrior = pFind;
   pNode->m_pNext = pFind->m_pNext;
   if (pFind->m_pNext)
     pFind->m_pNext->m_pPrior = pNode;
   pFind->m_pNext = pNode;
   return iCount;
 }
+
 void CFDE_XMLNode::RemoveChildNode(CFDE_XMLNode* pNode) {
   ASSERT(m_pChild && pNode);
   if (m_pChild == pNode) {
     m_pChild = pNode->m_pNext;
   } else {
     pNode->m_pPrior->m_pNext = pNode->m_pNext;
   }
   if (pNode->m_pNext)
     pNode->m_pNext->m_pPrior = pNode->m_pPrior;
   pNode->m_pParent = nullptr;
@@ skipping 123 matching lines @@
       } else if (m_pParent) {
         m_pParent->m_pChild = pNode;
       }
       m_pPrior = pNode;
       return TRUE;
     }
     default:
       return FALSE;
   }
 }
+
 CFDE_XMLNode* CFDE_XMLNode::RemoveNodeItem(CFDE_XMLNode::NodeItem eItem) {
   CFDE_XMLNode* pNode = nullptr;
   switch (eItem) {
     case CFDE_XMLNode::NextSibling:
       if (m_pNext) {
         pNode = m_pNext;
         m_pNext = pNode->m_pNext;
         if (m_pNext) {
           m_pNext->m_pPrior = this;
         }
         pNode->m_pParent = nullptr;
         pNode->m_pNext = nullptr;
         pNode->m_pPrior = nullptr;
       }
       break;
     default:
       break;
   }
   return pNode;
 }
+
 CFDE_XMLNode* CFDE_XMLNode::Clone(FX_BOOL bRecursive) {
   return nullptr;
 }
+
 void CFDE_XMLNode::SaveXMLNode(IFX_Stream* pXMLStream) {
   CFDE_XMLNode* pNode = (CFDE_XMLNode*)this;
   switch (pNode->GetType()) {
     case FDE_XMLNODE_Instruction: {
       CFX_WideString ws;
       CFDE_XMLInstruction* pInstruction = (CFDE_XMLInstruction*)pNode;
       if (pInstruction->m_wsTarget.CompareNoCase(L"xml") == 0) {
         ws = L"<?xml version=\"1.0\" encoding=\"";
         uint16_t wCodePage = pXMLStream->GetCodePage();
         if (wCodePage == FX_CODEPAGE_UTF16LE) {
@@ skipping 89 matching lines @@
       ws += ((CFDE_XMLCharData*)pNode)->m_wsCharData;
       ws += L"]]>";
       pXMLStream->WriteString(ws.c_str(), ws.GetLength());
     } break;
     case FDE_XMLNODE_Unknown:
       break;
     default:
       break;
   }
 }
+
 void CFDE_XMLNode::CloneChildren(CFDE_XMLNode* pClone) {
   if (!m_pChild) {
     return;
   }
   CFDE_XMLNode* pNext = m_pChild;
   CFDE_XMLNode* pCloneNext = pNext->Clone(TRUE);
   pClone->InsertChildNode(pCloneNext);
   pNext = pNext->m_pNext;
   while (pNext) {
     CFDE_XMLNode* pChild = pNext->Clone(TRUE);
     pCloneNext->InsertNodeItem(CFDE_XMLNode::NextSibling, pChild);
     pCloneNext = pChild;
     pNext = pNext->m_pNext;
   }
 }
 
 CFDE_XMLInstruction::CFDE_XMLInstruction(const CFX_WideString& wsTarget)
     : m_wsTarget(wsTarget) {
   ASSERT(m_wsTarget.GetLength() > 0);
 }
+
+void CFDE_XMLInstruction::Release() {
+  delete this;
+}
+
+FDE_XMLNODETYPE CFDE_XMLInstruction::GetType() const {
+  return FDE_XMLNODE_Instruction;
+}
+
 CFDE_XMLNode* CFDE_XMLInstruction::Clone(FX_BOOL bRecursive) {
   CFDE_XMLInstruction* pClone = new CFDE_XMLInstruction(m_wsTarget);
   if (!pClone) {
     return pClone;
   }
   pClone->m_Attributes.Copy(m_Attributes);
   pClone->m_TargetData.Copy(m_TargetData);
   if (bRecursive) {
     CloneChildren(pClone);
   }
   return pClone;
 }
+
 int32_t CFDE_XMLInstruction::CountAttributes() const {
   return m_Attributes.GetSize() / 2;
 }
+
 FX_BOOL CFDE_XMLInstruction::GetAttribute(int32_t index,
                                           CFX_WideString& wsAttriName,
                                           CFX_WideString& wsAttriValue) const {
   int32_t iCount = m_Attributes.GetSize();
   ASSERT(index > -1 && index < iCount / 2);
   for (int32_t i = 0; i < iCount; i += 2) {
     if (index == 0) {
       wsAttriName = m_Attributes[i];
       wsAttriValue = m_Attributes[i + 1];
       return TRUE;
     }
     index--;
   }
   return FALSE;
 }
+
 FX_BOOL CFDE_XMLInstruction::HasAttribute(const FX_WCHAR* pwsAttriName) const {
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(pwsAttriName) == 0) {
       return TRUE;
     }
   }
   return FALSE;
 }
+
 void CFDE_XMLInstruction::GetString(const FX_WCHAR* pwsAttriName,
                                     CFX_WideString& wsAttriValue,
                                     const FX_WCHAR* pwsDefValue) const {
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(pwsAttriName) == 0) {
       wsAttriValue = m_Attributes[i + 1];
       return;
     }
   }
   wsAttriValue = pwsDefValue;
 }
+
 void CFDE_XMLInstruction::SetString(const CFX_WideString& wsAttriName,
                                     const CFX_WideString& wsAttriValue) {
   ASSERT(wsAttriName.GetLength() > 0);
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(wsAttriName) == 0) {
       m_Attributes[i] = wsAttriName;
       m_Attributes[i + 1] = wsAttriValue;
       return;
     }
   }
   m_Attributes.Add(wsAttriName);
   m_Attributes.Add(wsAttriValue);
 }
+
 int32_t CFDE_XMLInstruction::GetInteger(const FX_WCHAR* pwsAttriName,
                                         int32_t iDefValue) const {
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(pwsAttriName) == 0) {
       return FXSYS_wtoi(m_Attributes[i + 1].c_str());
     }
   }
   return iDefValue;
 }
+
 void CFDE_XMLInstruction::SetInteger(const FX_WCHAR* pwsAttriName,
                                      int32_t iAttriValue) {
   CFX_WideString wsValue;
   wsValue.Format(L"%d", iAttriValue);
   SetString(pwsAttriName, wsValue);
 }
+
 FX_FLOAT CFDE_XMLInstruction::GetFloat(const FX_WCHAR* pwsAttriName,
                                        FX_FLOAT fDefValue) const {
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(pwsAttriName) == 0) {
       return FX_wcstof(m_Attributes[i + 1].c_str());
     }
   }
   return fDefValue;
 }
+
 void CFDE_XMLInstruction::SetFloat(const FX_WCHAR* pwsAttriName,
                                    FX_FLOAT fAttriValue) {
   CFX_WideString wsValue;
   wsValue.Format(L"%f", fAttriValue);
   SetString(pwsAttriName, wsValue);
 }
+
 void CFDE_XMLInstruction::RemoveAttribute(const FX_WCHAR* pwsAttriName) {
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(pwsAttriName) == 0) {
       m_Attributes.RemoveAt(i + 1);
       m_Attributes.RemoveAt(i);
       return;
     }
   }
 }
+
 int32_t CFDE_XMLInstruction::CountData() const {
   return m_TargetData.GetSize();
 }
+
 FX_BOOL CFDE_XMLInstruction::GetData(int32_t index,
                                      CFX_WideString& wsData) const {
   if (index < 0 || index >= m_TargetData.GetSize()) {
     return FALSE;
   }
   wsData = m_TargetData[index];
   return TRUE;
 }
+
 void CFDE_XMLInstruction::AppendData(const CFX_WideString& wsData) {
   m_TargetData.Add(wsData);
 }
+
 void CFDE_XMLInstruction::RemoveData(int32_t index) {
   m_TargetData.RemoveAt(index);
 }
 
+CFDE_XMLInstruction::~CFDE_XMLInstruction() {}
+
 CFDE_XMLElement::CFDE_XMLElement(const CFX_WideString& wsTag)
     : CFDE_XMLNode(), m_wsTag(wsTag), m_Attributes() {
   ASSERT(m_wsTag.GetLength() > 0);
 }
+
 CFDE_XMLElement::~CFDE_XMLElement() {
   m_Attributes.RemoveAll();
 }
+
+void CFDE_XMLElement::Release() {
+  delete this;
+}
+
+FDE_XMLNODETYPE CFDE_XMLElement::GetType() const {
+  return FDE_XMLNODE_Element;
+}
+
 CFDE_XMLNode* CFDE_XMLElement::Clone(FX_BOOL bRecursive) {
   CFDE_XMLElement* pClone = new CFDE_XMLElement(m_wsTag);
   if (!pClone) {
     return nullptr;
   }
   pClone->m_Attributes.Copy(m_Attributes);
   if (bRecursive) {
     CloneChildren(pClone);
   } else {
     CFX_WideString wsText;
     CFDE_XMLNode* pChild = m_pChild;
     while (pChild) {
       switch (pChild->GetType()) {
         case FDE_XMLNODE_Text:
           wsText += ((CFDE_XMLText*)pChild)->m_wsText;
           break;
         default:
           break;
       }
       pChild = pChild->m_pNext;
     }
     pClone->SetTextData(wsText);
   }
   return pClone;
 }
+
 void CFDE_XMLElement::GetTagName(CFX_WideString& wsTag) const {
   wsTag = m_wsTag;
 }
+
 void CFDE_XMLElement::GetLocalTagName(CFX_WideString& wsTag) const {
   FX_STRSIZE iFind = m_wsTag.Find(L':', 0);
   if (iFind < 0) {
     wsTag = m_wsTag;
   } else {
     wsTag = m_wsTag.Right(m_wsTag.GetLength() - iFind - 1);
   }
 }
+
 void CFDE_XMLElement::GetNamespacePrefix(CFX_WideString& wsPrefix) const {
   FX_STRSIZE iFind = m_wsTag.Find(L':', 0);
   if (iFind < 0) {
     wsPrefix.clear();
   } else {
     wsPrefix = m_wsTag.Left(iFind);
   }
 }
+
 void CFDE_XMLElement::GetNamespaceURI(CFX_WideString& wsNamespace) const {
   CFX_WideString wsAttri(L"xmlns"), wsPrefix;
   GetNamespacePrefix(wsPrefix);
   if (wsPrefix.GetLength() > 0) {
     wsAttri += L":";
     wsAttri += wsPrefix;
   }
   wsNamespace.clear();
   CFDE_XMLNode* pNode = (CFDE_XMLNode*)this;
   while (pNode) {
     if (pNode->GetType() != FDE_XMLNODE_Element) {
       break;
     }
     CFDE_XMLElement* pElement = (CFDE_XMLElement*)pNode;
     if (!pElement->HasAttribute(wsAttri.c_str())) {
       pNode = pNode->GetNodeItem(CFDE_XMLNode::Parent);
       continue;
     }
     pElement->GetString(wsAttri.c_str(), wsNamespace);
     break;
   }
 }
+
 int32_t CFDE_XMLElement::CountAttributes() const {
   return m_Attributes.GetSize() / 2;
 }
+
 FX_BOOL CFDE_XMLElement::GetAttribute(int32_t index,
                                       CFX_WideString& wsAttriName,
                                       CFX_WideString& wsAttriValue) const {
   int32_t iCount = m_Attributes.GetSize();
   ASSERT(index > -1 && index < iCount / 2);
   for (int32_t i = 0; i < iCount; i += 2) {
     if (index == 0) {
       wsAttriName = m_Attributes[i];
       wsAttriValue = m_Attributes[i + 1];
       return TRUE;
     }
     index--;
   }
   return FALSE;
 }
+
 FX_BOOL CFDE_XMLElement::HasAttribute(const FX_WCHAR* pwsAttriName) const {
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(pwsAttriName) == 0) {
       return TRUE;
     }
   }
   return FALSE;
 }
+
 void CFDE_XMLElement::GetString(const FX_WCHAR* pwsAttriName,
                                 CFX_WideString& wsAttriValue,
                                 const FX_WCHAR* pwsDefValue) const {
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(pwsAttriName) == 0) {
       wsAttriValue = m_Attributes[i + 1];
       return;
     }
   }
   wsAttriValue = pwsDefValue;
 }
+
 void CFDE_XMLElement::SetString(const CFX_WideString& wsAttriName,
                                 const CFX_WideString& wsAttriValue) {
   ASSERT(wsAttriName.GetLength() > 0);
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(wsAttriName) == 0) {
       m_Attributes[i] = wsAttriName;
       m_Attributes[i + 1] = wsAttriValue;
       return;
     }
   }
   m_Attributes.Add(wsAttriName);
   m_Attributes.Add(wsAttriValue);
 }
+
 int32_t CFDE_XMLElement::GetInteger(const FX_WCHAR* pwsAttriName,
                                     int32_t iDefValue) const {
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(pwsAttriName) == 0) {
       return FXSYS_wtoi(m_Attributes[i + 1].c_str());
     }
   }
   return iDefValue;
 }
+
 void CFDE_XMLElement::SetInteger(const FX_WCHAR* pwsAttriName,
                                  int32_t iAttriValue) {
   CFX_WideString wsValue;
   wsValue.Format(L"%d", iAttriValue);
   SetString(pwsAttriName, wsValue);
 }
+
 FX_FLOAT CFDE_XMLElement::GetFloat(const FX_WCHAR* pwsAttriName,
                                    FX_FLOAT fDefValue) const {
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(pwsAttriName) == 0) {
       return FX_wcstof(m_Attributes[i + 1].c_str());
     }
   }
   return fDefValue;
 }
+
 void CFDE_XMLElement::SetFloat(const FX_WCHAR* pwsAttriName,
                                FX_FLOAT fAttriValue) {
   CFX_WideString wsValue;
   wsValue.Format(L"%f", fAttriValue);
   SetString(pwsAttriName, wsValue);
 }
+
 void CFDE_XMLElement::RemoveAttribute(const FX_WCHAR* pwsAttriName) {
   int32_t iCount = m_Attributes.GetSize();
   for (int32_t i = 0; i < iCount; i += 2) {
     if (m_Attributes[i].Compare(pwsAttriName) == 0) {
       m_Attributes.RemoveAt(i + 1);
       m_Attributes.RemoveAt(i);
       return;
     }
   }
 }
+
 void CFDE_XMLElement::GetTextData(CFX_WideString& wsText) const {
   CFX_WideTextBuf buffer;
   CFDE_XMLNode* pChild = m_pChild;
   while (pChild) {
     switch (pChild->GetType()) {
       case FDE_XMLNODE_Text:
         buffer << ((CFDE_XMLText*)pChild)->m_wsText;
         break;
       case FDE_XMLNODE_CharData:
         buffer << ((CFDE_XMLCharData*)pChild)->m_wsCharData;
         break;
       default:
         break;
     }
     pChild = pChild->m_pNext;
   }
   wsText = buffer.AsStringC();
 }
+
 void CFDE_XMLElement::SetTextData(const CFX_WideString& wsText) {
   if (wsText.GetLength() < 1) {
     return;
   }
   InsertChildNode(new CFDE_XMLText(wsText));
 }
+
 CFDE_XMLText::CFDE_XMLText(const CFX_WideString& wsText)
     : CFDE_XMLNode(), m_wsText(wsText) {}
+
+void CFDE_XMLText::Release() {
+  delete this;
+}
+
+FDE_XMLNODETYPE CFDE_XMLText::GetType() const {
+  return FDE_XMLNODE_Text;
+}
+
 CFDE_XMLNode* CFDE_XMLText::Clone(FX_BOOL bRecursive) {
   CFDE_XMLText* pClone = new CFDE_XMLText(m_wsText);
   return pClone;
 }
 
+CFDE_XMLText::~CFDE_XMLText() {}
+
 CFDE_XMLCharData::CFDE_XMLCharData(const CFX_WideString& wsCData)
     : CFDE_XMLDeclaration(), m_wsCharData(wsCData) {}
+
+void CFDE_XMLCharData::Release() {
+  delete this;
+}
+
+FDE_XMLNODETYPE CFDE_XMLCharData::GetType() const {
+  return FDE_XMLNODE_CharData;
+}
+
 CFDE_XMLNode* CFDE_XMLCharData::Clone(FX_BOOL bRecursive) {
   CFDE_XMLCharData* pClone = new CFDE_XMLCharData(m_wsCharData);
   return pClone;
 }
 
+CFDE_XMLCharData::~CFDE_XMLCharData() {}
+
 CFDE_XMLDoc::CFDE_XMLDoc()
     : m_pRoot(nullptr), m_pSyntaxParser(nullptr), m_pXMLParser(nullptr) {
   Reset(TRUE);
   CFDE_XMLInstruction* pXML = new CFDE_XMLInstruction(L"xml");
   m_pRoot->InsertChildNode(pXML);
 }
+
 CFDE_XMLDoc::~CFDE_XMLDoc() {
   Reset(FALSE);
 }
+
 void CFDE_XMLDoc::Reset(FX_BOOL bInitRoot) {
   m_iStatus = 0;
   m_pStream = nullptr;
   if (bInitRoot) {
     if (m_pRoot)
       m_pRoot->DeleteChildren();
     else
       m_pRoot = new CFDE_XMLNode;
   } else {
     if (m_pRoot) {
       m_pRoot->Release();
       m_pRoot = nullptr;
     }
   }
   ReleaseParser();
 }
+
 void CFDE_XMLDoc::ReleaseParser() {
   if (m_pXMLParser) {
     m_pXMLParser->Release();
     m_pXMLParser = nullptr;
   }
   if (m_pSyntaxParser) {
     m_pSyntaxParser->Release();
     m_pSyntaxParser = nullptr;
   }
 }
 
 FX_BOOL CFDE_XMLDoc::LoadXML(CFDE_XMLParser* pXMLParser) {
   if (!pXMLParser)
     return FALSE;
 
   Reset(TRUE);
   m_pXMLParser = pXMLParser;
   return !!m_pXMLParser;
 }
+
 int32_t CFDE_XMLDoc::DoLoad(IFX_Pause* pPause) {
   if (m_iStatus >= 100)
     return m_iStatus;
   return m_iStatus = m_pXMLParser->DoParser(pPause);
 }
+
 void CFDE_XMLDoc::CloseXML() {
   ReleaseParser();
 }
+
 void CFDE_XMLDoc::SaveXMLNode(IFX_Stream* pXMLStream, CFDE_XMLNode* pINode) {
   CFDE_XMLNode* pNode = (CFDE_XMLNode*)pINode;
   switch (pNode->GetType()) {
     case FDE_XMLNODE_Instruction: {
       CFX_WideString ws;
       CFDE_XMLInstruction* pInstruction = (CFDE_XMLInstruction*)pNode;
       if (pInstruction->m_wsTarget.CompareNoCase(L"xml") == 0) {
         ws = L"<?xml version=\"1.0\" encoding=\"";
         uint16_t wCodePage = pXMLStream->GetCodePage();
         if (wCodePage == FX_CODEPAGE_UTF16LE) {
@@ skipping 89 matching lines @@
       ws += ((CFDE_XMLCharData*)pNode)->m_wsCharData;
       ws += L"]]>";
       pXMLStream->WriteString(ws.c_str(), ws.GetLength());
     } break;
     case FDE_XMLNODE_Unknown:
       break;
     default:
       break;
   }
 }
+
 void CFDE_XMLDoc::SaveXML(IFX_Stream* pXMLStream, FX_BOOL bSaveBOM) {
   if (!pXMLStream || pXMLStream == m_pStream) {
     m_pStream->Seek(FX_STREAMSEEK_Begin, 0);
     pXMLStream = m_pStream;
   }
   ASSERT((pXMLStream->GetAccessModes() & FX_STREAMACCESS_Text) != 0);
   ASSERT((pXMLStream->GetAccessModes() & FX_STREAMACCESS_Write) != 0);
   uint16_t wCodePage = pXMLStream->GetCodePage();
   if (wCodePage != FX_CODEPAGE_UTF16LE && wCodePage != FX_CODEPAGE_UTF16BE &&
       wCodePage != FX_CODEPAGE_UTF8) {
@@ skipping 12 matching lines @@
     int32_t iPos = pXMLStream->GetPosition();
     pXMLStream->SetLength(iPos);
   }
 }
 
 CFDE_BlockBuffer::CFDE_BlockBuffer(int32_t iAllocStep)
     : m_iDataLength(0),
       m_iBufferSize(0),
       m_iAllocStep(iAllocStep),
       m_iStartPosition(0) {}
+
 CFDE_BlockBuffer::~CFDE_BlockBuffer() {
   ClearBuffer();
 }
+
 FX_WCHAR* CFDE_BlockBuffer::GetAvailableBlock(int32_t& iIndexInBlock) {
   iIndexInBlock = 0;
   if (!m_BlockArray.GetSize()) {
     return nullptr;
   }
   int32_t iRealIndex = m_iStartPosition + m_iDataLength;
   if (iRealIndex == m_iBufferSize) {
     FX_WCHAR* pBlock = FX_Alloc(FX_WCHAR, m_iAllocStep);
     m_BlockArray.Add(pBlock);
     m_iBufferSize += m_iAllocStep;
     return pBlock;
   }
   iIndexInBlock = iRealIndex % m_iAllocStep;
   return m_BlockArray[iRealIndex / m_iAllocStep];
 }
+
 FX_BOOL CFDE_BlockBuffer::InitBuffer(int32_t iBufferSize) {
   ClearBuffer();
   int32_t iNumOfBlock = (iBufferSize - 1) / m_iAllocStep + 1;
   for (int32_t i = 0; i < iNumOfBlock; i++) {
     m_BlockArray.Add(FX_Alloc(FX_WCHAR, m_iAllocStep));
   }
   m_iBufferSize = iNumOfBlock * m_iAllocStep;
   return TRUE;
 }
+
 void CFDE_BlockBuffer::SetTextChar(int32_t iIndex, FX_WCHAR ch) {
   if (iIndex < 0) {
     return;
   }
   int32_t iRealIndex = m_iStartPosition + iIndex;
   int32_t iBlockIndex = iRealIndex / m_iAllocStep;
   int32_t iInnerIndex = iRealIndex % m_iAllocStep;
   int32_t iBlockSize = m_BlockArray.GetSize();
   if (iBlockIndex >= iBlockSize) {
     int32_t iNewBlocks = iBlockIndex - iBlockSize + 1;
     do {
       FX_WCHAR* pBlock = FX_Alloc(FX_WCHAR, m_iAllocStep);
       m_BlockArray.Add(pBlock);
       m_iBufferSize += m_iAllocStep;
     } while (--iNewBlocks);
   }
   FX_WCHAR* pTextData = m_BlockArray[iBlockIndex];
   *(pTextData + iInnerIndex) = ch;
   if (m_iDataLength <= iIndex) {
     m_iDataLength = iIndex + 1;
   }
 }
+
 int32_t CFDE_BlockBuffer::DeleteTextChars(int32_t iCount, FX_BOOL bDirection) {
   if (iCount <= 0) {
     return m_iDataLength;
   }
   if (iCount >= m_iDataLength) {
     Reset(FALSE);
     return 0;
   }
   if (bDirection) {
     m_iStartPosition += iCount;
     m_iDataLength -= iCount;
   } else {
     m_iDataLength -= iCount;
   }
   return m_iDataLength;
 }
+
 void CFDE_BlockBuffer::GetTextData(CFX_WideString& wsTextData,
                                    int32_t iStart,
                                    int32_t iLength) const {
   wsTextData.clear();
   int32_t iMaybeDataLength = m_iBufferSize - 1 - m_iStartPosition;
   if (iStart < 0 || iStart > iMaybeDataLength) {
     return;
   }
   if (iLength == -1 || iLength > iMaybeDataLength) {
     iLength = iMaybeDataLength;
@@ skipping 22 matching lines @@
     if (i == iEndBlockIndex) {
       iCopyLength -= ((m_iAllocStep - 1) - iEndInnerIndex);
     }
     FX_WCHAR* pBlockBuf = m_BlockArray[i];
     FXSYS_memcpy(pBuf + iPointer, pBlockBuf + iBufferPointer,
                  iCopyLength * sizeof(FX_WCHAR));
     iPointer += iCopyLength;
   }
   wsTextData.ReleaseBuffer(iLength);
 }
+
 void CFDE_BlockBuffer::TextDataIndex2BufIndex(const int32_t iIndex,
                                               int32_t& iBlockIndex,
                                               int32_t& iInnerIndex) const {
   ASSERT(iIndex >= 0);
   int32_t iRealIndex = m_iStartPosition + iIndex;
   iBlockIndex = iRealIndex / m_iAllocStep;
   iInnerIndex = iRealIndex % m_iAllocStep;
 }
+
 void CFDE_BlockBuffer::ClearBuffer() {
   m_iBufferSize = 0;
   int32_t iSize = m_BlockArray.GetSize();
   for (int32_t i = 0; i < iSize; i++) {
     FX_Free(m_BlockArray[i]);
   }
   m_BlockArray.RemoveAll();
 }
 
 CFDE_XMLSyntaxParser::CFDE_XMLSyntaxParser()
@@ skipping 16 matching lines @@
       m_iIndexInBlock(0),
       m_iTextDataLength(0),
       m_syntaxParserResult(FDE_XmlSyntaxResult::None),
       m_syntaxParserState(FDE_XmlSyntaxState::Text),
       m_wQuotationMark(0),
       m_iEntityStart(-1),
       m_SkipStack(16) {
   m_CurNode.iNodeNum = -1;
   m_CurNode.eNodeType = FDE_XMLNODE_Unknown;
 }
+
 void CFDE_XMLSyntaxParser::Init(IFX_Stream* pStream,
                                 int32_t iXMLPlaneSize,
                                 int32_t iTextDataSize) {
   ASSERT(!m_pStream && !m_pBuffer);
   ASSERT(pStream && iXMLPlaneSize > 0);
   int32_t iStreamLength = pStream->GetLength();
   ASSERT(iStreamLength > 0);
   m_pStream = pStream;
   m_iXMLPlaneSize = std::min(iXMLPlaneSize, iStreamLength);
   uint8_t bom[4];
@@ skipping 521 matching lines @@
       nbytes = 4;
     } else if ((uint32_t)unicode < 0x4000000) {
       nbytes = 5;
     } else {
       nbytes = 6;
     }
     iDstNum += nbytes;
   }
   return iDstNum;
 }
+
 FX_FILESIZE CFDE_XMLSyntaxParser::GetCurrentBinaryPos() const {
   if (!m_pStream)
     return 0;
 
   int32_t nSrcLen = m_pStart - m_pBuffer;
   int32_t nDstLen = FX_GetUTF8EncodeLength(m_pBuffer, nSrcLen);
   return m_iParsedBytes + nDstLen;
 }
 
 void CFDE_XMLSyntaxParser::ParseTextChar(FX_WCHAR ch) {
@@ skipping 62 matching lines @@
     m_BlockBuffer.DeleteTextChars(m_iDataLength - m_iEntityStart, FALSE);
     m_pCurrentBlock = m_BlockBuffer.GetAvailableBlock(m_iIndexInBlock);
     m_iEntityStart = -1;
   } else {
     if (m_iEntityStart < 0 && ch == L'&') {
       m_iEntityStart = m_iDataLength - 1;
     }
   }
   m_pStart++;
 }