Remove IFDE_XML* classes.

xfa/fxfa/parser/xfa_parser_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/fxfa/parser/xfa_parser_imp.h"
 
+#include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fxfa/fm2js/xfa_fm2jsapi.h"
 #include "xfa/fxfa/parser/xfa_basic_imp.h"
 #include "xfa/fxfa/parser/xfa_docdata.h"
 #include "xfa/fxfa/parser/xfa_doclayout.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 #include "xfa/fxfa/parser/xfa_localemgr.h"
 #include "xfa/fxfa/parser/xfa_object.h"
 #include "xfa/fxfa/parser/xfa_parser.h"
 #include "xfa/fxfa/parser/xfa_script.h"
@@ skipping 12 matching lines @@
       m_pFactory(pFactory),
       m_pRootNode(nullptr),
       m_ePacketID(XFA_XDPPACKET_UNKNOWN),
       m_bDocumentParser(bDocumentParser) {}
 CXFA_SimpleParser::~CXFA_SimpleParser() {
   CloseParser();
 }
 void CXFA_SimpleParser::SetFactory(IXFA_ObjFactory* pFactory) {
   m_pFactory = pFactory;
 }
-static IFDE_XMLNode* XFA_FDEExtension_GetDocumentNode(
-    IFDE_XMLDoc* pXMLDoc,
+static CFDE_XMLNode* XFA_FDEExtension_GetDocumentNode(
+    CFDE_XMLDoc* pXMLDoc,
     FX_BOOL bVerifyWellFormness = FALSE) {
   if (!pXMLDoc) {
     return NULL;
   }
-  IFDE_XMLNode* pXMLFakeRoot = pXMLDoc->GetRoot();
-  for (IFDE_XMLNode* pXMLNode =
-           pXMLFakeRoot->GetNodeItem(IFDE_XMLNode::FirstChild);
-       pXMLNode; pXMLNode = pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+  CFDE_XMLNode* pXMLFakeRoot = pXMLDoc->GetRoot();
+  for (CFDE_XMLNode* pXMLNode =
+           pXMLFakeRoot->GetNodeItem(CFDE_XMLNode::FirstChild);
+       pXMLNode; pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
       if (bVerifyWellFormness) {
-        for (IFDE_XMLNode* pNextNode =
-                 pXMLNode->GetNodeItem(IFDE_XMLNode::NextSibling);
+        for (CFDE_XMLNode* pNextNode =
+                 pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling);
              pNextNode;
-             pNextNode = pNextNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+             pNextNode = pNextNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
           if (pNextNode->GetType() == FDE_XMLNODE_Element) {
             return FALSE;
           }
         }
       }
       return pXMLNode;
     }
   }
   return NULL;
 }
 int32_t CXFA_SimpleParser::StartParse(IFX_FileRead* pStream,
                                       XFA_XDPPACKET ePacketID) {
   CloseParser();
   m_pFileRead = pStream;
   m_pStream = IFX_Stream::CreateStream(
       pStream, FX_STREAMACCESS_Read | FX_STREAMACCESS_Text);
   if (m_pStream == NULL) {
     return XFA_PARSESTATUS_StreamErr;
   }
   uint16_t wCodePage = m_pStream->GetCodePage();
   if (wCodePage != FX_CODEPAGE_UTF16LE && wCodePage != FX_CODEPAGE_UTF16BE &&
       wCodePage != FX_CODEPAGE_UTF8) {
     m_pStream->SetCodePage(FX_CODEPAGE_UTF8);
   }
-  m_pXMLDoc = IFDE_XMLDoc::Create();
-  if (m_pXMLDoc == NULL) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
+  m_pXMLDoc = new CFDE_XMLDoc;
   m_pXMLParser = new CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream);
-  if (m_pXMLParser == NULL) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
   if (!m_pXMLDoc->LoadXML(m_pXMLParser)) {
     return XFA_PARSESTATUS_StatusErr;
   }
   m_ePacketID = ePacketID;
   return XFA_PARSESTATUS_Ready;
 }
 int32_t CXFA_SimpleParser::DoParse(IFX_Pause* pPause) {
   if (m_pXMLDoc == NULL || m_ePacketID == XFA_XDPPACKET_UNKNOWN) {
     return XFA_PARSESTATUS_StatusErr;
   }
@@ skipping 10 matching lines @@
   if (m_pStream) {
     m_pStream->Release();
     m_pStream = NULL;
   }
   if (!m_pRootNode) {
     return XFA_PARSESTATUS_StatusErr;
   }
   return XFA_PARSESTATUS_Done;
 }
 int32_t CXFA_SimpleParser::ParseXMLData(const CFX_WideString& wsXML,
-                                        IFDE_XMLNode*& pXMLNode,
+                                        CFDE_XMLNode*& pXMLNode,
                                         IFX_Pause* pPause) {
   CloseParser();
   pXMLNode = NULL;
   IFX_Stream* pStream = XFA_CreateWideTextRead(wsXML);
   if (!pStream) {
     return XFA_PARSESTATUS_StreamErr;
   }
   m_pStream = pStream;
-  m_pXMLDoc = IFDE_XMLDoc::Create();
-  if (m_pXMLDoc == NULL) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
+  m_pXMLDoc = new CFDE_XMLDoc;
   CXFA_XMLParser* pParser = new CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream);
-  if (pParser == NULL) {
-    return XFA_PARSESTATUS_StatusErr;
-  }
-
   pParser->m_dwCheckStatus = 0x03;
   if (!m_pXMLDoc->LoadXML(pParser)) {
     return XFA_PARSESTATUS_StatusErr;
   }
   int32_t iRet = m_pXMLDoc->DoLoad(pPause);
   if (iRet < 0 || iRet >= 100) {
     m_pXMLDoc->CloseXML();
   }
   if (iRet < 0) {
     return XFA_PARSESTATUS_SyntaxErr;
   }
   if (iRet < 100) {
     return iRet / 2;
   }
   if (m_pStream) {
     m_pStream->Release();
     m_pStream = NULL;
   }
   pXMLNode = XFA_FDEExtension_GetDocumentNode(m_pXMLDoc);
   return XFA_PARSESTATUS_Done;
 }
 
 void CXFA_SimpleParser::ConstructXFANode(CXFA_Node* pXFANode,
-                                         IFDE_XMLNode* pXMLNode) {
+                                         CFDE_XMLNode* pXMLNode) {
   XFA_XDPPACKET ePacketID = (XFA_XDPPACKET)pXFANode->GetPacketID();
   if (ePacketID == XFA_XDPPACKET_Datasets) {
     if (pXFANode->GetClassID() == XFA_ELEMENT_DataValue) {
-      for (IFDE_XMLNode* pXMLChild =
-               pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+      for (CFDE_XMLNode* pXMLChild =
+               pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
            pXMLChild;
-           pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+           pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
         FDE_XMLNODETYPE eNodeType = pXMLChild->GetType();
         if (eNodeType == FDE_XMLNODE_Instruction)
           continue;
 
         if (eNodeType == FDE_XMLNODE_Element) {
           CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets,
                                                         XFA_ELEMENT_DataValue);
           if (!pXFAChild)
             return;
 
           CFX_WideString wsNodeStr;
-          ((IFDE_XMLElement*)pXMLChild)->GetLocalTagName(wsNodeStr);
+          CFDE_XMLElement* child = static_cast<CFDE_XMLElement*>(pXMLChild);
+          child->GetLocalTagName(wsNodeStr);
           pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr);
           CFX_WideString wsChildValue;
-          XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild,
-                                       wsChildValue);
+          XFA_GetPlainTextFromRichText(child, wsChildValue);
           if (!wsChildValue.IsEmpty())
             pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsChildValue);
 
           pXFANode->InsertChild(pXFAChild);
           pXFAChild->SetXMLMappingNode(pXMLChild);
           pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
           break;
         }
       }
       m_pRootNode = pXFANode;
     } else {
       m_pRootNode = DataLoader(pXFANode, pXMLNode, TRUE);
     }
   } else if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) {
     ParseContentNode(pXFANode, pXMLNode, ePacketID);
     m_pRootNode = pXFANode;
   } else {
     m_pRootNode = NormalLoader(pXFANode, pXMLNode, ePacketID);
   }
 }
 
 FX_BOOL XFA_FDEExtension_ResolveNamespaceQualifier(
-    IFDE_XMLElement* pNode,
+    CFDE_XMLElement* pNode,
     const CFX_WideStringC& wsQualifier,
     CFX_WideString& wsNamespaceURI) {
   if (!pNode) {
     return FALSE;
   }
-  IFDE_XMLNode* pFakeRoot = pNode->GetNodeItem(IFDE_XMLNode::Root);
+  CFDE_XMLNode* pFakeRoot = pNode->GetNodeItem(CFDE_XMLNode::Root);
   CFX_WideString wsNSAttribute;
   FX_BOOL bRet = FALSE;
   if (wsQualifier.IsEmpty()) {
     wsNSAttribute = FX_WSTRC(L"xmlns");
     bRet = TRUE;
   } else {
     wsNSAttribute = FX_WSTRC(L"xmlns:") + wsQualifier;
   }
-  for (; pNode != pFakeRoot;
-       pNode = (IFDE_XMLElement*)pNode->GetNodeItem(IFDE_XMLNode::Parent)) {
+  for (; pNode != pFakeRoot; pNode = static_cast<CFDE_XMLElement*>(
+                                 pNode->GetNodeItem(CFDE_XMLNode::Parent))) {
     if (pNode->GetType() != FDE_XMLNODE_Element) {
       continue;
     }
     if (pNode->HasAttribute(wsNSAttribute)) {
       pNode->GetString(wsNSAttribute, wsNamespaceURI);
       return TRUE;
     }
   }
   wsNamespaceURI.Empty();
   return bRet;
 }
 static inline void XFA_FDEExtension_GetElementTagNamespaceURI(
-    IFDE_XMLElement* pElement,
+    CFDE_XMLElement* pElement,
     CFX_WideString& wsNamespaceURI) {
   CFX_WideString wsNodeStr;
   pElement->GetNamespacePrefix(wsNodeStr);
   if (!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNodeStr,
                                                   wsNamespaceURI)) {
     wsNamespaceURI.Empty();
   }
 }
 static FX_BOOL XFA_FDEExtension_MatchNodeName(
-    IFDE_XMLNode* pNode,
+    CFDE_XMLNode* pNode,
     const CFX_WideStringC& wsLocalTagName,
     const CFX_WideStringC& wsNamespaceURIPrefix,
     uint32_t eMatchFlags = XFA_XDPPACKET_FLAGS_NOMATCH) {
   if (!pNode || pNode->GetType() != FDE_XMLNODE_Element) {
     return FALSE;
   }
-  IFDE_XMLElement* pElement = reinterpret_cast<IFDE_XMLElement*>(pNode);
+  CFDE_XMLElement* pElement = reinterpret_cast<CFDE_XMLElement*>(pNode);
   CFX_WideString wsNodeStr;
   pElement->GetLocalTagName(wsNodeStr);
   if (wsNodeStr != wsLocalTagName) {
     return FALSE;
   }
   XFA_FDEExtension_GetElementTagNamespaceURI(pElement, wsNodeStr);
   if (eMatchFlags & XFA_XDPPACKET_FLAGS_NOMATCH) {
     return TRUE;
   }
   if (eMatchFlags & XFA_XDPPACKET_FLAGS_PREFIXMATCH) {
     return wsNodeStr.Left(wsNamespaceURIPrefix.GetLength()) ==
            wsNamespaceURIPrefix;
   }
   return wsNodeStr == wsNamespaceURIPrefix;
 }
 static FX_BOOL XFA_FDEExtension_GetAttributeLocalName(
     const CFX_WideStringC& wsAttributeName,
     CFX_WideString& wsLocalAttrName) {
   CFX_WideString wsAttrName(wsAttributeName);
   FX_STRSIZE iFind = wsAttrName.Find(L':', 0);
   if (iFind < 0) {
     wsLocalAttrName = wsAttrName;
     return FALSE;
   } else {
     wsLocalAttrName = wsAttrName.Right(wsAttrName.GetLength() - iFind - 1);
     return TRUE;
   }
 }
 static FX_BOOL XFA_FDEExtension_ResolveAttribute(
-    IFDE_XMLElement* pElement,
+    CFDE_XMLElement* pElement,
     const CFX_WideStringC& wsAttributeName,
     CFX_WideString& wsLocalAttrName,
     CFX_WideString& wsNamespaceURI) {
   CFX_WideString wsAttrName(wsAttributeName);
   CFX_WideString wsNSPrefix;
   if (XFA_FDEExtension_GetAttributeLocalName(wsAttributeName,
                                              wsLocalAttrName)) {
     wsNSPrefix = wsAttrName.Left(wsAttributeName.GetLength() -
                                  wsLocalAttrName.GetLength() - 1);
   }
   if (wsLocalAttrName == FX_WSTRC(L"xmlns") ||
       wsNSPrefix == FX_WSTRC(L"xmlns") || wsNSPrefix == FX_WSTRC(L"xml")) {
     return FALSE;
   }
   if (!XFA_FDEExtension_ResolveNamespaceQualifier(pElement, wsNSPrefix,
                                                   wsNamespaceURI)) {
     wsNamespaceURI.Empty();
     return FALSE;
   }
   return TRUE;
 }
 static FX_BOOL XFA_FDEExtension_FindAttributeWithNS(
-    IFDE_XMLElement* pElement,
+    CFDE_XMLElement* pElement,
     const CFX_WideStringC& wsLocalAttributeName,
     const CFX_WideStringC& wsNamespaceURIPrefix,
     CFX_WideString& wsValue,
     FX_BOOL bMatchNSAsPrefix = FALSE) {
   if (!pElement) {
     return FALSE;
   }
   CFX_WideString wsAttrName;
   CFX_WideString wsAttrValue;
   CFX_WideString wsAttrNS;
@@ skipping 25 matching lines @@
     } else {
       if (wsAttrNS != wsNamespaceURIPrefix) {
         continue;
       }
     }
     wsValue = wsAttrValue;
     return TRUE;
   }
   return FALSE;
 }
-CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket(IFDE_XMLNode* pXMLDocumentNode,
+CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket(CFDE_XMLNode* pXMLDocumentNode,
                                                XFA_XDPPACKET ePacketID) {
   switch (ePacketID) {
     case XFA_XDPPACKET_UNKNOWN:
       return NULL;
     case XFA_XDPPACKET_XDP:
       return ParseAsXDPPacket_XDP(pXMLDocumentNode, ePacketID);
     case XFA_XDPPACKET_Config:
       return ParseAsXDPPacket_Config(pXMLDocumentNode, ePacketID);
     case XFA_XDPPACKET_Template:
     case XFA_XDPPACKET_Form:
       return ParseAsXDPPacket_TemplateForm(pXMLDocumentNode, ePacketID);
     case XFA_XDPPACKET_Datasets:
       return ParseAsXDPPacket_Data(pXMLDocumentNode, ePacketID);
     case XFA_XDPPACKET_Xdc:
       return ParseAsXDPPacket_Xdc(pXMLDocumentNode, ePacketID);
     case XFA_XDPPACKET_LocaleSet:
     case XFA_XDPPACKET_ConnectionSet:
     case XFA_XDPPACKET_SourceSet:
       return ParseAsXDPPacket_LocaleConnectionSourceSet(pXMLDocumentNode,
                                                         ePacketID);
     default:
       return ParseAsXDPPacket_User(pXMLDocumentNode, ePacketID);
   }
   return NULL;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_XDP(
-    IFDE_XMLNode* pXMLDocumentNode,
+    CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   if (!XFA_FDEExtension_MatchNodeName(
           pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_XDP)->pName,
           XFA_GetPacketByIndex(XFA_PACKET_XDP)->pURI,
           XFA_GetPacketByIndex(XFA_PACKET_XDP)->eFlags)) {
     return nullptr;
   }
   CXFA_Node* pXFARootNode =
       m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_ELEMENT_Xfa);
   if (!pXFARootNode) {
     return nullptr;
   }
   m_pRootNode = pXFARootNode;
   pXFARootNode->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L"xfa"));
   {
-    IFDE_XMLElement* pElement = (IFDE_XMLElement*)pXMLDocumentNode;
+    CFDE_XMLElement* pElement = static_cast<CFDE_XMLElement*>(pXMLDocumentNode);
     int32_t iAttributeCount = pElement->CountAttributes();
     for (int32_t i = 0; i < iAttributeCount; i++) {
       CFX_WideString wsAttriName, wsAttriValue;
       pElement->GetAttribute(i, wsAttriName, wsAttriValue);
       if (wsAttriName == FX_WSTRC(L"uuid")) {
         pXFARootNode->SetCData(XFA_ATTRIBUTE_Uuid, wsAttriValue);
       } else if (wsAttriName == FX_WSTRC(L"timeStamp")) {
         pXFARootNode->SetCData(XFA_ATTRIBUTE_TimeStamp, wsAttriValue);
       }
     }
   }
-  IFDE_XMLNode* pXMLConfigDOMRoot = nullptr;
+  CFDE_XMLNode* pXMLConfigDOMRoot = nullptr;
   CXFA_Node* pXFAConfigDOMRoot = nullptr;
   {
-    for (IFDE_XMLNode* pChildItem =
-             pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+    for (CFDE_XMLNode* pChildItem =
+             pXMLDocumentNode->GetNodeItem(CFDE_XMLNode::FirstChild);
          pChildItem;
-         pChildItem = pChildItem->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+         pChildItem = pChildItem->GetNodeItem(CFDE_XMLNode::NextSibling)) {
       const XFA_PACKETINFO* pPacketInfo =
           XFA_GetPacketByIndex(XFA_PACKET_Config);
       if (!XFA_FDEExtension_MatchNodeName(pChildItem, pPacketInfo->pName,
                                           pPacketInfo->pURI,
                                           pPacketInfo->eFlags)) {
         continue;
       }
       if (pXFARootNode->GetFirstChildByName(pPacketInfo->uHash)) {
         return nullptr;
       }
       pXMLConfigDOMRoot = pChildItem;
       pXFAConfigDOMRoot =
           ParseAsXDPPacket_Config(pXMLConfigDOMRoot, XFA_XDPPACKET_Config);
       pXFARootNode->InsertChild(pXFAConfigDOMRoot, NULL);
     }
   }
-  IFDE_XMLNode* pXMLDatasetsDOMRoot = nullptr;
-  IFDE_XMLNode* pXMLFormDOMRoot = nullptr;
-  IFDE_XMLNode* pXMLTemplateDOMRoot = nullptr;
+  CFDE_XMLNode* pXMLDatasetsDOMRoot = nullptr;
+  CFDE_XMLNode* pXMLFormDOMRoot = nullptr;
+  CFDE_XMLNode* pXMLTemplateDOMRoot = nullptr;
   {
-    for (IFDE_XMLNode* pChildItem =
-             pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+    for (CFDE_XMLNode* pChildItem =
+             pXMLDocumentNode->GetNodeItem(CFDE_XMLNode::FirstChild);
          pChildItem;
-         pChildItem = pChildItem->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+         pChildItem = pChildItem->GetNodeItem(CFDE_XMLNode::NextSibling)) {
       if (!pChildItem || pChildItem->GetType() != FDE_XMLNODE_Element) {
         continue;
       }
       if (pChildItem == pXMLConfigDOMRoot) {
         continue;
       }
-      IFDE_XMLElement* pElement =
-          reinterpret_cast<IFDE_XMLElement*>(pChildItem);
+      CFDE_XMLElement* pElement =
+          reinterpret_cast<CFDE_XMLElement*>(pChildItem);
       CFX_WideString wsPacketName;
       pElement->GetLocalTagName(wsPacketName);
       const XFA_PACKETINFO* pPacketInfo = XFA_GetPacketByName(wsPacketName);
       if (pPacketInfo && pPacketInfo->pURI) {
         if (!XFA_FDEExtension_MatchNodeName(pElement, pPacketInfo->pName,
                                             pPacketInfo->pURI,
                                             pPacketInfo->eFlags)) {
           pPacketInfo = nullptr;
         }
       }
@@ skipping 50 matching lines @@
     CXFA_Node* pPacketNode =
         ParseAsXDPPacket(pXMLFormDOMRoot, XFA_XDPPACKET_Form);
     if (pPacketNode) {
       pXFARootNode->InsertChild(pPacketNode);
     }
   }
   pXFARootNode->SetXMLMappingNode(pXMLDocumentNode);
   return pXFARootNode;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Config(
-    IFDE_XMLNode* pXMLDocumentNode,
+    CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   if (!XFA_FDEExtension_MatchNodeName(
           pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Config)->pName,
           XFA_GetPacketByIndex(XFA_PACKET_Config)->pURI,
           XFA_GetPacketByIndex(XFA_PACKET_Config)->eFlags)) {
     return NULL;
   }
   CXFA_Node* pNode =
       m_pFactory->CreateNode(XFA_XDPPACKET_Config, XFA_ELEMENT_Config);
   if (!pNode) {
     return NULL;
   }
   pNode->SetCData(XFA_ATTRIBUTE_Name,
                   XFA_GetPacketByIndex(XFA_PACKET_Config)->pName);
   if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
     return NULL;
   }
   pNode->SetXMLMappingNode(pXMLDocumentNode);
   return pNode;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_TemplateForm(
-    IFDE_XMLNode* pXMLDocumentNode,
+    CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode = NULL;
   if (ePacketID == XFA_XDPPACKET_Template) {
     if (XFA_FDEExtension_MatchNodeName(
             pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Template)->pName,
             XFA_GetPacketByIndex(XFA_PACKET_Template)->pURI,
             XFA_GetPacketByIndex(XFA_PACKET_Template)->eFlags)) {
       pNode =
           m_pFactory->CreateNode(XFA_XDPPACKET_Template, XFA_ELEMENT_Template);
       if (!pNode) {
         return NULL;
       }
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_Template)->pName);
       if (m_bDocumentParser) {
         CFX_WideString wsNamespaceURI;
-        IFDE_XMLElement* pXMLDocumentElement =
-            (IFDE_XMLElement*)pXMLDocumentNode;
+        CFDE_XMLElement* pXMLDocumentElement =
+            static_cast<CFDE_XMLElement*>(pXMLDocumentNode);
         pXMLDocumentElement->GetNamespaceURI(wsNamespaceURI);
         if (wsNamespaceURI.IsEmpty()) {
           pXMLDocumentElement->GetString(L"xmlns:xfa", wsNamespaceURI);
         }
         pNode->GetDocument()->RecognizeXFAVersionNumber(wsNamespaceURI);
       }
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
         return NULL;
       }
     }
   } else if (ePacketID == XFA_XDPPACKET_Form) {
     if (XFA_FDEExtension_MatchNodeName(
             pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Form)->pName,
             XFA_GetPacketByIndex(XFA_PACKET_Form)->pURI,
             XFA_GetPacketByIndex(XFA_PACKET_Form)->eFlags)) {
-      IFDE_XMLElement* pXMLDocumentElement = (IFDE_XMLElement*)pXMLDocumentNode;
+      CFDE_XMLElement* pXMLDocumentElement =
+          static_cast<CFDE_XMLElement*>(pXMLDocumentNode);
       CFX_WideString wsChecksum;
       pXMLDocumentElement->GetString(L"checksum", wsChecksum);
       if (wsChecksum.GetLength() != 28 ||
           m_pXMLParser->m_dwCheckStatus != 0x03) {
         return NULL;
       }
       IXFA_ChecksumContext* pChecksum = XFA_Checksum_Create();
       pChecksum->StartChecksum();
       pChecksum->UpdateChecksum(m_pFileRead, m_pXMLParser->m_nStart[0],
                                 m_pXMLParser->m_nSize[0]);
@@ skipping 29 matching lines @@
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID, bUseAttribute)) {
         return NULL;
       }
     }
   }
   if (pNode) {
     pNode->SetXMLMappingNode(pXMLDocumentNode);
   }
   return pNode;
 }
-static IFDE_XMLNode* XFA_GetDataSetsFromXDP(IFDE_XMLNode* pXMLDocumentNode) {
+static CFDE_XMLNode* XFA_GetDataSetsFromXDP(CFDE_XMLNode* pXMLDocumentNode) {
   if (XFA_FDEExtension_MatchNodeName(
           pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName,
           XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI,
           XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
     return pXMLDocumentNode;
   }
   if (!XFA_FDEExtension_MatchNodeName(
           pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_XDP)->pName,
           XFA_GetPacketByIndex(XFA_PACKET_XDP)->pURI,
           XFA_GetPacketByIndex(XFA_PACKET_XDP)->eFlags)) {
     return NULL;
   }
-  for (IFDE_XMLNode* pDatasetsNode =
-           pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+  for (CFDE_XMLNode* pDatasetsNode =
+           pXMLDocumentNode->GetNodeItem(CFDE_XMLNode::FirstChild);
        pDatasetsNode;
-       pDatasetsNode = pDatasetsNode->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+       pDatasetsNode = pDatasetsNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     if (!XFA_FDEExtension_MatchNodeName(
             pDatasetsNode, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName,
             XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI,
             XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
       continue;
     }
     return pDatasetsNode;
   }
   return NULL;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Data(
-    IFDE_XMLNode* pXMLDocumentNode,
+    CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
-  IFDE_XMLNode* pDatasetsXMLNode = XFA_GetDataSetsFromXDP(pXMLDocumentNode);
+  CFDE_XMLNode* pDatasetsXMLNode = XFA_GetDataSetsFromXDP(pXMLDocumentNode);
   if (pDatasetsXMLNode) {
     CXFA_Node* pNode =
         m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataModel);
     if (!pNode) {
       return NULL;
     }
     pNode->SetCData(XFA_ATTRIBUTE_Name,
                     XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName);
     if (!DataLoader(pNode, pDatasetsXMLNode, FALSE)) {
       return NULL;
     }
     pNode->SetXMLMappingNode(pDatasetsXMLNode);
     return pNode;
   }
-  IFDE_XMLNode* pDataXMLNode = NULL;
+  CFDE_XMLNode* pDataXMLNode = NULL;
   if (XFA_FDEExtension_MatchNodeName(
           pXMLDocumentNode, FX_WSTRC(L"data"),
           XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI,
           XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
-    ((IFDE_XMLElement*)pXMLDocumentNode)->RemoveAttribute(L"xmlns:xfa");
+    static_cast<CFDE_XMLElement*>(pXMLDocumentNode)
+        ->RemoveAttribute(L"xmlns:xfa");
     pDataXMLNode = pXMLDocumentNode;
   } else {
-    IFDE_XMLElement* pDataElement =
-        IFDE_XMLElement::Create(FX_WSTRC(L"xfa:data"));
-    IFDE_XMLNode* pParentXMLNode =
-        pXMLDocumentNode->GetNodeItem(IFDE_XMLNode::Parent);
+    CFDE_XMLElement* pDataElement = new CFDE_XMLElement(FX_WSTRC(L"xfa:data"));
+    CFDE_XMLNode* pParentXMLNode =
+        pXMLDocumentNode->GetNodeItem(CFDE_XMLNode::Parent);
     if (pParentXMLNode) {
       pParentXMLNode->RemoveChildNode(pXMLDocumentNode);
     }
     FXSYS_assert(pXMLDocumentNode->GetType() == FDE_XMLNODE_Element);
     if (pXMLDocumentNode->GetType() == FDE_XMLNODE_Element) {
-      ((IFDE_XMLElement*)pXMLDocumentNode)->RemoveAttribute(L"xmlns:xfa");
+      static_cast<CFDE_XMLElement*>(pXMLDocumentNode)
+          ->RemoveAttribute(L"xmlns:xfa");
     }
     pDataElement->InsertChildNode(pXMLDocumentNode);
     pDataXMLNode = pDataElement;
   }
   if (pDataXMLNode) {
     CXFA_Node* pNode =
         m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataGroup);
     if (!pNode) {
       if (pDataXMLNode != pXMLDocumentNode) {
         pDataXMLNode->Release();
       }
       return NULL;
     }
     CFX_WideString wsLocalName;
-    ((IFDE_XMLElement*)pDataXMLNode)->GetLocalTagName(wsLocalName);
+    static_cast<CFDE_XMLElement*>(pDataXMLNode)->GetLocalTagName(wsLocalName);
     pNode->SetCData(XFA_ATTRIBUTE_Name, wsLocalName);
     if (!DataLoader(pNode, pDataXMLNode, TRUE)) {
       return NULL;
     }
     pNode->SetXMLMappingNode(pDataXMLNode);
     if (pDataXMLNode != pXMLDocumentNode) {
       pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
     }
     return pNode;
   }
   return NULL;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_LocaleConnectionSourceSet(
-    IFDE_XMLNode* pXMLDocumentNode,
+    CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode = NULL;
   if (ePacketID == XFA_XDPPACKET_LocaleSet) {
     if (XFA_FDEExtension_MatchNodeName(
             pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName,
             XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pURI,
             XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->eFlags)) {
       pNode = m_pFactory->CreateNode(XFA_XDPPACKET_LocaleSet,
                                      XFA_ELEMENT_LocaleSet);
       if (!pNode) {
@@ skipping 38 matching lines @@
         return NULL;
       }
     }
   }
   if (pNode) {
     pNode->SetXMLMappingNode(pXMLDocumentNode);
   }
   return pNode;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Xdc(
-    IFDE_XMLNode* pXMLDocumentNode,
+    CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   if (XFA_FDEExtension_MatchNodeName(
           pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName,
           XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pURI,
           XFA_GetPacketByIndex(XFA_PACKET_Xdc)->eFlags)) {
     CXFA_Node* pNode =
         m_pFactory->CreateNode(XFA_XDPPACKET_Xdc, XFA_ELEMENT_Xdc);
     if (!pNode) {
       return NULL;
     }
     pNode->SetCData(XFA_ATTRIBUTE_Name,
                     XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName);
     pNode->SetXMLMappingNode(pXMLDocumentNode);
     return pNode;
   }
   return NULL;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_User(
-    IFDE_XMLNode* pXMLDocumentNode,
+    CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode =
       m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_ELEMENT_Packet);
   if (!pNode) {
     return NULL;
   }
   CFX_WideString wsName;
-  ((IFDE_XMLElement*)pXMLDocumentNode)->GetLocalTagName(wsName);
+  static_cast<CFDE_XMLElement*>(pXMLDocumentNode)->GetLocalTagName(wsName);
   pNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
   if (!UserPacketLoader(pNode, pXMLDocumentNode)) {
     return NULL;
   }
   pNode->SetXMLMappingNode(pXMLDocumentNode);
   return pNode;
 }
 CXFA_Node* CXFA_SimpleParser::UserPacketLoader(CXFA_Node* pXFANode,
-                                               IFDE_XMLNode* pXMLDoc) {
+                                               CFDE_XMLNode* pXMLDoc) {
   return pXFANode;
 }
 static FX_BOOL XFA_FDEExtension_IsStringAllWhitespace(CFX_WideString wsText) {
   wsText.TrimRight(L"\x20\x9\xD\xA");
   return wsText.IsEmpty();
 }
 CXFA_Node* CXFA_SimpleParser::DataLoader(CXFA_Node* pXFANode,
-                                         IFDE_XMLNode* pXMLDoc,
+                                         CFDE_XMLNode* pXMLDoc,
                                          FX_BOOL bDoTransform) {
   ParseDataGroup(pXFANode, pXMLDoc, XFA_XDPPACKET_Datasets);
   return pXFANode;
 }
 CXFA_Node* CXFA_SimpleParser::NormalLoader(CXFA_Node* pXFANode,
-                                           IFDE_XMLNode* pXMLDoc,
+                                           CFDE_XMLNode* pXMLDoc,
                                            XFA_XDPPACKET ePacketID,
                                            FX_BOOL bUseAttribute) {
   FX_BOOL bOneOfPropertyFound = FALSE;
-  for (IFDE_XMLNode* pXMLChild = pXMLDoc->GetNodeItem(IFDE_XMLNode::FirstChild);
+  for (CFDE_XMLNode* pXMLChild = pXMLDoc->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLChild;
-       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+       pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     switch (pXMLChild->GetType()) {
       case FDE_XMLNODE_Element: {
-        IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLChild;
+        CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLChild);
         CFX_WideString wsTagName;
         pXMLElement->GetLocalTagName(wsTagName);
         const XFA_ELEMENTINFO* pElemInfo = XFA_GetElementByName(wsTagName);
         if (!pElemInfo) {
           continue;
         }
         const XFA_PROPERTY* pPropertyInfo = XFA_GetPropertyOfElement(
             pXFANode->GetClassID(), pElemInfo->eName, ePacketID);
         if (pPropertyInfo &&
             ((pPropertyInfo->uFlags &
@@ skipping 53 matching lines @@
             if (IsNeedValue) {
               ParseContentNode(pXFAChild, pXMLElement, ePacketID);
             }
             break;
           default:
             NormalLoader(pXFAChild, pXMLElement, ePacketID, bUseAttribute);
             break;
         }
       } break;
       case FDE_XMLNODE_Instruction:
-        ParseInstruction(pXFANode, (IFDE_XMLInstruction*)pXMLChild, ePacketID);
+        ParseInstruction(pXFANode, static_cast<CFDE_XMLInstruction*>(pXMLChild),
+                         ePacketID);
         break;
       default:
         break;
     }
   }
   return pXFANode;
 }
-FX_BOOL XFA_RecognizeRichText(IFDE_XMLElement* pRichTextXMLNode) {
+FX_BOOL XFA_RecognizeRichText(CFDE_XMLElement* pRichTextXMLNode) {
   if (pRichTextXMLNode) {
     CFX_WideString wsNamespaceURI;
     XFA_FDEExtension_GetElementTagNamespaceURI(pRichTextXMLNode,
                                                wsNamespaceURI);
     if (wsNamespaceURI == FX_WSTRC(L"http://www.w3.org/1999/xhtml")) {
       return TRUE;
     }
   }
   return FALSE;
 }
 class RichTextNodeVisitor {
  public:
-  static inline IFDE_XMLNode* GetFirstChild(IFDE_XMLNode* pNode) {
-    return pNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+  static inline CFDE_XMLNode* GetFirstChild(CFDE_XMLNode* pNode) {
+    return pNode->GetNodeItem(CFDE_XMLNode::FirstChild);
   }
-  static inline IFDE_XMLNode* GetNextSibling(IFDE_XMLNode* pNode) {
-    return pNode->GetNodeItem(IFDE_XMLNode::NextSibling);
+  static inline CFDE_XMLNode* GetNextSibling(CFDE_XMLNode* pNode) {
+    return pNode->GetNodeItem(CFDE_XMLNode::NextSibling);
   }
-  static inline IFDE_XMLNode* GetParent(IFDE_XMLNode* pNode) {
-    return pNode->GetNodeItem(IFDE_XMLNode::Parent);
+  static inline CFDE_XMLNode* GetParent(CFDE_XMLNode* pNode) {
+    return pNode->GetNodeItem(CFDE_XMLNode::Parent);
   }
 };
 
-void XFA_ConvertXMLToPlainText(IFDE_XMLElement* pRootXMLNode,
+void XFA_ConvertXMLToPlainText(CFDE_XMLElement* pRootXMLNode,
                                CFX_WideString& wsOutput) {
-  for (IFDE_XMLNode* pXMLChild =
-           pRootXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+  for (CFDE_XMLNode* pXMLChild =
+           pRootXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLChild;
-       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+       pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     switch (pXMLChild->GetType()) {
       case FDE_XMLNODE_Element: {
         CFX_WideString wsTextData;
-        ((IFDE_XMLElement*)pXMLChild)->GetTextData(wsTextData);
+        static_cast<CFDE_XMLElement*>(pXMLChild)->GetTextData(wsTextData);
         wsTextData += FX_WSTRC(L"\n");
         wsOutput += wsTextData;
       } break;
       case FDE_XMLNODE_Text: {
         CFX_WideString wsText;
-        ((IFDE_XMLText*)pXMLChild)->GetText(wsText);
+        static_cast<CFDE_XMLText*>(pXMLChild)->GetText(wsText);
         if (XFA_FDEExtension_IsStringAllWhitespace(wsText)) {
           continue;
         } else {
           wsOutput = wsText;
         }
       } break;
       case FDE_XMLNODE_CharData: {
         CFX_WideString wsCharData;
-        ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsCharData);
+        static_cast<CFDE_XMLCharData*>(pXMLChild)->GetCharData(wsCharData);
         if (XFA_FDEExtension_IsStringAllWhitespace(wsCharData)) {
           continue;
         } else {
           wsOutput = wsCharData;
         }
       } break;
       default:
         FXSYS_assert(FALSE);
         break;
     }
   }
 }
 
 void CXFA_SimpleParser::ParseContentNode(CXFA_Node* pXFANode,
-                                         IFDE_XMLNode* pXMLNode,
+                                         CFDE_XMLNode* pXMLNode,
                                          XFA_XDPPACKET ePacketID) {
   XFA_ELEMENT element = XFA_ELEMENT_Sharptext;
   if (pXFANode->GetClassID() == XFA_ELEMENT_ExData) {
     CFX_WideStringC wsContentType =
         pXFANode->GetCData(XFA_ATTRIBUTE_ContentType);
     if (wsContentType == FX_WSTRC(L"text/html"))
       element = XFA_ELEMENT_SharpxHTML;
     else if (wsContentType == FX_WSTRC(L"text/xml"))
       element = XFA_ELEMENT_Sharpxml;
   }
   if (element == XFA_ELEMENT_SharpxHTML)
     pXFANode->SetXMLMappingNode(pXMLNode);
 
   CFX_WideString wsValue;
-  for (IFDE_XMLNode* pXMLChild =
-           pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+  for (CFDE_XMLNode* pXMLChild =
+           pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLChild;
-       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+       pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     FDE_XMLNODETYPE eNodeType = pXMLChild->GetType();
     if (eNodeType == FDE_XMLNODE_Instruction)
       continue;
 
     if (element == XFA_ELEMENT_SharpxHTML) {
       if (eNodeType != FDE_XMLNODE_Element)
         break;
 
-      if (XFA_RecognizeRichText((IFDE_XMLElement*)pXMLChild))
-        XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild, wsValue);
+      if (XFA_RecognizeRichText(static_cast<CFDE_XMLElement*>(pXMLChild)))
+        XFA_GetPlainTextFromRichText(static_cast<CFDE_XMLElement*>(pXMLChild),
+                                     wsValue);
     } else if (element == XFA_ELEMENT_Sharpxml) {
       if (eNodeType != FDE_XMLNODE_Element)
         break;
-      XFA_ConvertXMLToPlainText((IFDE_XMLElement*)pXMLChild, wsValue);
+      XFA_ConvertXMLToPlainText(static_cast<CFDE_XMLElement*>(pXMLChild),
+                                wsValue);
     } else {
       if (eNodeType == FDE_XMLNODE_Element)
         break;
       if (eNodeType == FDE_XMLNODE_Text)
-        ((IFDE_XMLText*)pXMLChild)->GetText(wsValue);
+        static_cast<CFDE_XMLText*>(pXMLChild)->GetText(wsValue);
       else if (eNodeType == FDE_XMLNODE_CharData)
-        ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsValue);
+        static_cast<CFDE_XMLCharData*>(pXMLChild)->GetCharData(wsValue);
     }
     break;
   }
   if (!wsValue.IsEmpty()) {
     if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) {
       CXFA_Node* pContentRawDataNode =
           m_pFactory->CreateNode(ePacketID, element);
       FXSYS_assert(pContentRawDataNode);
       pContentRawDataNode->SetCData(XFA_ATTRIBUTE_Value, wsValue);
       pXFANode->InsertChild(pContentRawDataNode);
     } else {
       pXFANode->SetCData(XFA_ATTRIBUTE_Value, wsValue);
     }
   }
 }
 
 void CXFA_SimpleParser::ParseDataGroup(CXFA_Node* pXFANode,
-                                       IFDE_XMLNode* pXMLNode,
+                                       CFDE_XMLNode* pXMLNode,
                                        XFA_XDPPACKET ePacketID) {
-  for (IFDE_XMLNode* pXMLChild =
-           pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+  for (CFDE_XMLNode* pXMLChild =
+           pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLChild;
-       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+       pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     switch (pXMLChild->GetType()) {
       case FDE_XMLNODE_Element: {
-        IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLChild;
+        CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLChild);
         {
           CFX_WideString wsNamespaceURI;
           XFA_FDEExtension_GetElementTagNamespaceURI(pXMLElement,
                                                      wsNamespaceURI);
           if (wsNamespaceURI ==
                   FX_WSTRC(L"http://www.xfa.com/schema/xfa-package/") ||
               wsNamespaceURI ==
                   FX_WSTRC(L"http://www.xfa.org/schema/xfa-package/") ||
               wsNamespaceURI ==
                   FX_WSTRC(L"http://www.w3.org/2001/XMLSchema-instance")) {
@@ skipping 22 matching lines @@
           if (XFA_FDEExtension_FindAttributeWithNS(
                   pXMLElement, FX_WSTRC(L"contentType"),
                   FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/"),
                   wsContentType)) {
             if (!wsContentType.IsEmpty()) {
               eNodeType = XFA_ELEMENT_DataValue;
             }
           }
         }
         if (eNodeType == XFA_ELEMENT_DataModel) {
-          for (IFDE_XMLNode* pXMLDataChild =
-                   pXMLElement->GetNodeItem(IFDE_XMLNode::FirstChild);
+          for (CFDE_XMLNode* pXMLDataChild =
+                   pXMLElement->GetNodeItem(CFDE_XMLNode::FirstChild);
                pXMLDataChild; pXMLDataChild = pXMLDataChild->GetNodeItem(
-                                  IFDE_XMLNode::NextSibling)) {
+                                  CFDE_XMLNode::NextSibling)) {
             if (pXMLDataChild->GetType() == FDE_XMLNODE_Element) {
-              if (!XFA_RecognizeRichText((IFDE_XMLElement*)pXMLDataChild)) {
+              if (!XFA_RecognizeRichText(
+                      static_cast<CFDE_XMLElement*>(pXMLDataChild))) {
                 eNodeType = XFA_ELEMENT_DataGroup;
                 break;
               }
             }
           }
         }
         if (eNodeType == XFA_ELEMENT_DataModel) {
           eNodeType = XFA_ELEMENT_DataValue;
         }
         CXFA_Node* pXFAChild =
@@ skipping 62 matching lines @@
         } else {
           if (bNeedValue) {
             ParseDataValue(pXFAChild, pXMLChild, XFA_XDPPACKET_Datasets);
           }
         }
         pXFAChild->SetXMLMappingNode(pXMLElement);
         pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
       }
         continue;
       case FDE_XMLNODE_CharData: {
-        IFDE_XMLCharData* pXMLCharData = (IFDE_XMLCharData*)pXMLChild;
+        CFDE_XMLCharData* pXMLCharData =
+            static_cast<CFDE_XMLCharData*>(pXMLChild);
         CFX_WideString wsCharData;
         pXMLCharData->GetCharData(wsCharData);
         if (XFA_FDEExtension_IsStringAllWhitespace(wsCharData)) {
           continue;
         }
         CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets,
                                                       XFA_ELEMENT_DataValue);
         if (pXFAChild == NULL) {
           return;
         }
         pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCharData);
         pXFANode->InsertChild(pXFAChild);
         pXFAChild->SetXMLMappingNode(pXMLCharData);
         pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
       }
         continue;
       case FDE_XMLNODE_Text: {
-        IFDE_XMLText* pXMLText = (IFDE_XMLText*)pXMLChild;
+        CFDE_XMLText* pXMLText = static_cast<CFDE_XMLText*>(pXMLChild);
         CFX_WideString wsText;
         pXMLText->GetText(wsText);
         if (XFA_FDEExtension_IsStringAllWhitespace(wsText)) {
           continue;
         }
         CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets,
                                                       XFA_ELEMENT_DataValue);
         if (pXFAChild == NULL) {
           return;
         }
         pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsText);
         pXFANode->InsertChild(pXFAChild);
         pXFAChild->SetXMLMappingNode(pXMLText);
         pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
       }
         continue;
       case FDE_XMLNODE_Instruction:
         continue;
       default:
         continue;
     }
   }
 }
 
 void CXFA_SimpleParser::ParseDataValue(CXFA_Node* pXFANode,
-                                       IFDE_XMLNode* pXMLNode,
+                                       CFDE_XMLNode* pXMLNode,
                                        XFA_XDPPACKET ePacketID) {
   CFX_WideTextBuf wsValueTextBuf;
   CFX_WideTextBuf wsCurValueTextBuf;
   FX_BOOL bMarkAsCompound = FALSE;
-  IFDE_XMLNode* pXMLCurValueNode = nullptr;
-  for (IFDE_XMLNode* pXMLChild =
-           pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+  CFDE_XMLNode* pXMLCurValueNode = nullptr;
+  for (CFDE_XMLNode* pXMLChild =
+           pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLChild;
-       pXMLChild = pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling)) {
+       pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     FDE_XMLNODETYPE eNodeType = pXMLChild->GetType();
     if (eNodeType == FDE_XMLNODE_Instruction)
       continue;
 
     CFX_WideString wsText;
     if (eNodeType == FDE_XMLNODE_Text) {
-      ((IFDE_XMLText*)pXMLChild)->GetText(wsText);
+      static_cast<CFDE_XMLText*>(pXMLChild)->GetText(wsText);
       if (!pXMLCurValueNode)
         pXMLCurValueNode = pXMLChild;
 
       wsCurValueTextBuf << wsText;
     } else if (eNodeType == FDE_XMLNODE_CharData) {
-      ((IFDE_XMLCharData*)pXMLChild)->GetCharData(wsText);
+      static_cast<CFDE_XMLCharData*>(pXMLChild)->GetCharData(wsText);
       if (!pXMLCurValueNode)
         pXMLCurValueNode = pXMLChild;
 
       wsCurValueTextBuf << wsText;
-    } else if (XFA_RecognizeRichText((IFDE_XMLElement*)pXMLChild)) {
-      XFA_GetPlainTextFromRichText((IFDE_XMLElement*)pXMLChild, wsText);
+    } else if (XFA_RecognizeRichText(
+                   static_cast<CFDE_XMLElement*>(pXMLChild))) {
+      XFA_GetPlainTextFromRichText(static_cast<CFDE_XMLElement*>(pXMLChild),
+                                   wsText);
       if (!pXMLCurValueNode)
         pXMLCurValueNode = pXMLChild;
 
       wsCurValueTextBuf << wsText;
     } else {
       bMarkAsCompound = TRUE;
       if (pXMLCurValueNode) {
         CFX_WideStringC wsCurValue = wsCurValueTextBuf.GetWideString();
         if (!wsCurValue.IsEmpty()) {
           CXFA_Node* pXFAChild =
@@ skipping 10 matching lines @@
           wsCurValueTextBuf.Clear();
         }
         pXMLCurValueNode = nullptr;
       }
       CXFA_Node* pXFAChild =
           m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
       if (!pXFAChild)
         return;
 
       CFX_WideString wsNodeStr;
-      ((IFDE_XMLElement*)pXMLChild)->GetLocalTagName(wsNodeStr);
+      static_cast<CFDE_XMLElement*>(pXMLChild)->GetLocalTagName(wsNodeStr);
       pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr);
       ParseDataValue(pXFAChild, pXMLChild, ePacketID);
       pXFANode->InsertChild(pXFAChild);
       pXFAChild->SetXMLMappingNode(pXMLChild);
       pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
       CFX_WideStringC wsCurValue = pXFAChild->GetCData(XFA_ATTRIBUTE_Value);
       wsValueTextBuf << wsCurValue;
     }
   }
   if (pXMLCurValueNode) {
@@ skipping 14 matching lines @@
       wsValueTextBuf << wsCurValue;
       wsCurValueTextBuf.Clear();
     }
     pXMLCurValueNode = nullptr;
   }
   CFX_WideStringC wsNodeValue = wsValueTextBuf.GetWideString();
   pXFANode->SetCData(XFA_ATTRIBUTE_Value, wsNodeValue);
 }
 
 void CXFA_SimpleParser::ParseInstruction(CXFA_Node* pXFANode,
-                                         IFDE_XMLInstruction* pXMLInstruction,
+                                         CFDE_XMLInstruction* pXMLInstruction,
                                          XFA_XDPPACKET ePacketID) {
   if (!m_bDocumentParser) {
     return;
   }
   CFX_WideString wsTargetName;
   pXMLInstruction->GetTargetName(wsTargetName);
   if (wsTargetName == FX_WSTRC(L"originalXFAVersion")) {
     CFX_WideString wsData;
     if (pXMLInstruction->GetData(0, wsData) &&
         (pXFANode->GetDocument()->RecognizeXFAVersionNumber(wsData) !=
@@ skipping 45 matching lines @@
 }
 int32_t CXFA_DocumentParser::DoParse(IFX_Pause* pPause) {
   int32_t nRetStatus = m_nodeParser.DoParse(pPause);
   if (nRetStatus >= XFA_PARSESTATUS_Done) {
     FXSYS_assert(m_pDocument);
     m_pDocument->SetRoot(m_nodeParser.GetRootNode());
   }
   return nRetStatus;
 }
 int32_t CXFA_DocumentParser::ParseXMLData(const CFX_WideString& wsXML,
-                                          IFDE_XMLNode*& pXMLNode,
+                                          CFDE_XMLNode*& pXMLNode,
                                           IFX_Pause* pPause) {
   CloseParser();
   int32_t nRetStatus = m_nodeParser.ParseXMLData(wsXML, pXMLNode, NULL);
   if (nRetStatus == XFA_PARSESTATUS_Done && pXMLNode) {
     m_pDocument = new CXFA_Document(this);
     m_nodeParser.SetFactory(m_pDocument);
   }
   return nRetStatus;
 }
 void CXFA_DocumentParser::ConstructXFANode(CXFA_Node* pXFANode,
-                                           IFDE_XMLNode* pXMLNode) {
+                                           CFDE_XMLNode* pXMLNode) {
   if (!pXFANode || !pXMLNode) {
     return;
   }
   m_nodeParser.ConstructXFANode(pXFANode, pXMLNode);
   CXFA_Node* pRootNode = m_nodeParser.GetRootNode();
   if (m_pDocument && pRootNode) {
     m_pDocument->SetRoot(pRootNode);
   }
 }
 void CXFA_DocumentParser::CloseParser() {
   if (m_pDocument) {
     delete m_pDocument;
     m_pDocument = NULL;
   }
   m_nodeParser.CloseParser();
 }
-CXFA_XMLParser::CXFA_XMLParser(IFDE_XMLNode* pRoot, IFX_Stream* pStream)
+CXFA_XMLParser::CXFA_XMLParser(CFDE_XMLNode* pRoot, IFX_Stream* pStream)
     : m_nElementStart(0),
       m_dwCheckStatus(0),
       m_dwCurrentCheckStatus(0),
       m_pRoot(pRoot),
       m_pStream(pStream),
       m_pParser(nullptr),
       m_pParent(pRoot),
       m_pChild(nullptr),
       m_NodeStack(16),
       m_dwStatus(FDE_XMLSYNTAXSTATUS_None) {
   ASSERT(m_pParent && m_pStream);
   m_NodeStack.Push(m_pParent);
-  m_pParser = IFDE_XMLSyntaxParser::Create();
+  m_pParser = new CFDE_XMLSyntaxParser;
   m_pParser->Init(m_pStream, 32 * 1024, 1024 * 1024);
 }
 CXFA_XMLParser::~CXFA_XMLParser() {
   if (m_pParser) {
     m_pParser->Release();
   }
   m_NodeStack.RemoveAll();
   m_ws1.Empty();
   m_ws2.Empty();
 }
@@ skipping 25 matching lines @@
         }
         break;
       case FDE_XMLSYNTAXSTATUS_ElementBreak:
         break;
       case FDE_XMLSYNTAXSTATUS_ElementClose:
         if (m_pChild->GetType() != FDE_XMLNODE_Element) {
           m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
           break;
         }
         m_pParser->GetTagName(m_ws1);
-        ((IFDE_XMLElement*)m_pChild)->GetTagName(m_ws2);
+        static_cast<CFDE_XMLElement*>(m_pChild)->GetTagName(m_ws2);
         if (m_ws1.GetLength() > 0 && !m_ws1.Equal(m_ws2)) {
           m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
           break;
         }
         m_NodeStack.Pop();
         if (m_NodeStack.GetSize() < 1) {
           m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
           break;
         } else if (m_dwCurrentCheckStatus != 0 && m_NodeStack.GetSize() == 2) {
           m_nSize[m_dwCurrentCheckStatus - 1] =
               m_pParser->GetCurrentBinaryPos() -
               m_nStart[m_dwCurrentCheckStatus - 1];
           m_dwCurrentCheckStatus = 0;
         }
 
-        m_pParent = (IFDE_XMLNode*)*m_NodeStack.GetTopElement();
+        m_pParent = static_cast<CFDE_XMLNode*>(*m_NodeStack.GetTopElement());
         m_pChild = m_pParent;
         iCount++;
         break;
       case FDE_XMLSYNTAXSTATUS_TargetName:
         m_pParser->GetTargetName(m_ws1);
         if (m_ws1 == FX_WSTRC(L"originalXFAVersion") ||
             m_ws1 == FX_WSTRC(L"acrobat")) {
-          m_pChild = IFDE_XMLInstruction::Create(m_ws1);
+          m_pChild = new CFDE_XMLInstruction(m_ws1);
           m_pParent->InsertChildNode(m_pChild);
         } else {
           m_pChild = NULL;
         }
         m_ws1.Empty();
         break;
       case FDE_XMLSYNTAXSTATUS_TagName:
         m_pParser->GetTagName(m_ws1);
-        m_pChild = IFDE_XMLElement::Create(m_ws1);
+        m_pChild = new CFDE_XMLElement(m_ws1);
         m_pParent->InsertChildNode(m_pChild);
         m_NodeStack.Push(m_pChild);
         m_pParent = m_pChild;
 
         if (m_dwCheckStatus != 0x03 && m_NodeStack.GetSize() == 3) {
           CFX_WideString wsTag;
-          ((IFDE_XMLElement*)m_pChild)->GetLocalTagName(wsTag);
+          static_cast<CFDE_XMLElement*>(m_pChild)->GetLocalTagName(wsTag);
           if (wsTag == FX_WSTRC(L"template")) {
             m_dwCheckStatus |= 0x01;
             m_dwCurrentCheckStatus = 0x01;
             m_nStart[0] = m_pParser->GetCurrentBinaryPos() -
                           (m_pParser->GetCurrentPos() - m_nElementStart);
           } else if (wsTag == FX_WSTRC(L"datasets")) {
             m_dwCheckStatus |= 0x02;
             m_dwCurrentCheckStatus = 0x02;
             m_nStart[1] = m_pParser->GetCurrentBinaryPos() -
                           (m_pParser->GetCurrentPos() - m_nElementStart);
           }
         }
         break;
       case FDE_XMLSYNTAXSTATUS_AttriName:
         m_pParser->GetAttributeName(m_ws1);
         break;
       case FDE_XMLSYNTAXSTATUS_AttriValue:
         if (m_pChild) {
           m_pParser->GetAttributeName(m_ws2);
           if (m_pChild->GetType() == FDE_XMLNODE_Element) {
-            ((IFDE_XMLElement*)m_pChild)->SetString(m_ws1, m_ws2);
+            static_cast<CFDE_XMLElement*>(m_pChild)->SetString(m_ws1, m_ws2);
           }
         }
         m_ws1.Empty();
         break;
       case FDE_XMLSYNTAXSTATUS_Text:
         m_pParser->GetTextData(m_ws1);
-        m_pChild = IFDE_XMLText::Create(m_ws1);
+        m_pChild = new CFDE_XMLText(m_ws1);
         m_pParent->InsertChildNode(m_pChild);
         m_pChild = m_pParent;
         break;
       case FDE_XMLSYNTAXSTATUS_CData:
         m_pParser->GetTextData(m_ws1);
-        m_pChild = IFDE_XMLCharData::Create(m_ws1);
+        m_pChild = new CFDE_XMLCharData(m_ws1);
         m_pParent->InsertChildNode(m_pChild);
         m_pChild = m_pParent;
         break;
       case FDE_XMLSYNTAXSTATUS_TargetData:
         if (m_pChild) {
           if (m_pChild->GetType() != FDE_XMLNODE_Instruction) {
             m_dwStatus = FDE_XMLSYNTAXSTATUS_Error;
             break;
           }
           if (!m_ws1.IsEmpty()) {
-            ((IFDE_XMLInstruction*)m_pChild)->AppendData(m_ws1);
+            static_cast<CFDE_XMLInstruction*>(m_pChild)->AppendData(m_ws1);
           }
           m_pParser->GetTargetData(m_ws1);
-          ((IFDE_XMLInstruction*)m_pChild)->AppendData(m_ws1);
+          static_cast<CFDE_XMLInstruction*>(m_pChild)->AppendData(m_ws1);
         }
         m_ws1.Empty();
         break;
       default:
         break;
     }
     if (m_dwStatus == FDE_XMLSYNTAXSTATUS_Error ||
         m_dwStatus == FDE_XMLSYNTAXSTATUS_EOS) {
       break;
     }
     if (pPause && iCount > 500 && pPause->NeedToPauseNow()) {
       break;
     }
   }
   return (m_dwStatus == FDE_XMLSYNTAXSTATUS_Error || m_NodeStack.GetSize() != 1)
              ? -1
              : m_pParser->GetStatus();
 }