Remove NULL in xfa/

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 <memory>
 
@@ skipping 29 matching lines @@
 void CXFA_SimpleParser::Release() {
   delete this;
 }
 void CXFA_SimpleParser::SetFactory(CXFA_Document* pFactory) {
   m_pFactory = pFactory;
 }
 static CFDE_XMLNode* XFA_FDEExtension_GetDocumentNode(
     CFDE_XMLDoc* pXMLDoc,
     FX_BOOL bVerifyWellFormness = FALSE) {
   if (!pXMLDoc) {
-    return NULL;
+    return nullptr;
   }
   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 (CFDE_XMLNode* pNextNode =
                  pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling);
              pNextNode;
              pNextNode = pNextNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
           if (pNextNode->GetType() == FDE_XMLNODE_Element) {
             return FALSE;
           }
         }
       }
       return pXMLNode;
     }
   }
-  return NULL;
+  return nullptr;
 }
 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) {
+  if (!m_pStream) {
     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 = new CFDE_XMLDoc;
   m_pXMLParser = new CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream);
   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) {
+  if (!m_pXMLDoc || m_ePacketID == XFA_XDPPACKET_UNKNOWN) {
     return XFA_PARSESTATUS_StatusErr;
   }
   int32_t iRet = m_pXMLDoc->DoLoad(pPause);
   if (iRet < 0) {
     return XFA_PARSESTATUS_SyntaxErr;
   }
   if (iRet < 100) {
     return iRet / 2;
   }
   m_pRootNode = ParseAsXDPPacket(XFA_FDEExtension_GetDocumentNode(m_pXMLDoc),
                                  m_ePacketID);
   m_pXMLDoc->CloseXML();
   if (m_pStream) {
     m_pStream->Release();
-    m_pStream = NULL;
+    m_pStream = nullptr;
   }
   if (!m_pRootNode) {
     return XFA_PARSESTATUS_StatusErr;
   }
   return XFA_PARSESTATUS_Done;
 }
 int32_t CXFA_SimpleParser::ParseXMLData(const CFX_WideString& wsXML,
                                         CFDE_XMLNode*& pXMLNode,
                                         IFX_Pause* pPause) {
   CloseParser();
-  pXMLNode = NULL;
+  pXMLNode = nullptr;
   IFX_Stream* pStream = XFA_CreateWideTextRead(wsXML);
   if (!pStream) {
     return XFA_PARSESTATUS_StreamErr;
   }
   m_pStream = pStream;
   m_pXMLDoc = new CFDE_XMLDoc;
   CXFA_XMLParser* pParser = new CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream);
   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;
+    m_pStream = nullptr;
   }
   pXMLNode = XFA_FDEExtension_GetDocumentNode(m_pXMLDoc);
   return XFA_PARSESTATUS_Done;
 }
 
 void CXFA_SimpleParser::ConstructXFANode(CXFA_Node* pXFANode,
                                          CFDE_XMLNode* pXMLNode) {
   XFA_XDPPACKET ePacketID = (XFA_XDPPACKET)pXFANode->GetPacketID();
   if (ePacketID == XFA_XDPPACKET_Datasets) {
     if (pXFANode->GetElementType() == XFA_Element::DataValue) {
@@ skipping 193 matching lines @@
     }
     wsValue = wsAttrValue;
     return TRUE;
   }
   return FALSE;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket(CFDE_XMLNode* pXMLDocumentNode,
                                                XFA_XDPPACKET ePacketID) {
   switch (ePacketID) {
     case XFA_XDPPACKET_UNKNOWN:
-      return NULL;
+      return nullptr;
     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:
@@ skipping 49 matching lines @@
                                           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);
+      pXFARootNode->InsertChild(pXFAConfigDOMRoot, nullptr);
     }
   }
   CFDE_XMLNode* pXMLDatasetsDOMRoot = nullptr;
   CFDE_XMLNode* pXMLFormDOMRoot = nullptr;
   CFDE_XMLNode* pXMLTemplateDOMRoot = nullptr;
   {
     for (CFDE_XMLNode* pChildItem =
              pXMLDocumentNode->GetNodeItem(CFDE_XMLNode::FirstChild);
          pChildItem;
          pChildItem = pChildItem->GetNodeItem(CFDE_XMLNode::NextSibling)) {
@@ skipping 75 matching lines @@
   pXFARootNode->SetXMLMappingNode(pXMLDocumentNode);
   return pXFARootNode;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Config(
     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;
+    return nullptr;
   }
   CXFA_Node* pNode =
       m_pFactory->CreateNode(XFA_XDPPACKET_Config, XFA_Element::Config);
   if (!pNode) {
-    return NULL;
+    return nullptr;
   }
   pNode->SetCData(XFA_ATTRIBUTE_Name,
                   XFA_GetPacketByIndex(XFA_PACKET_Config)->pName);
   if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
-    return NULL;
+    return nullptr;
   }
   pNode->SetXMLMappingNode(pXMLDocumentNode);
   return pNode;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_TemplateForm(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
-  CXFA_Node* pNode = NULL;
+  CXFA_Node* pNode = nullptr;
   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;
+        return nullptr;
       }
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_Template)->pName);
       if (m_bDocumentParser) {
         CFX_WideString wsNamespaceURI;
         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;
+        return nullptr;
       }
     }
   } 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)) {
       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;
+        return nullptr;
       }
       std::unique_ptr<CXFA_ChecksumContext> pChecksum(new CXFA_ChecksumContext);
       pChecksum->StartChecksum();
       pChecksum->UpdateChecksum(m_pFileRead, m_pXMLParser->m_nStart[0],
                                 m_pXMLParser->m_nSize[0]);
       pChecksum->UpdateChecksum(m_pFileRead, m_pXMLParser->m_nStart[1],
                                 m_pXMLParser->m_nSize[1]);
       pChecksum->FinishChecksum();
       CFX_ByteString bsCheck = pChecksum->GetChecksum();
       if (bsCheck != wsChecksum.UTF8Encode())
         return nullptr;
 
       pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Form, XFA_Element::Form);
       if (!pNode)
         return nullptr;
 
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_Form)->pName);
       pNode->SetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum.AsStringC());
       CXFA_Node* pTemplateRoot =
           m_pRootNode->GetFirstChildByClass(XFA_Element::Template);
       CXFA_Node* pTemplateChosen =
           pTemplateRoot
               ? pTemplateRoot->GetFirstChildByClass(XFA_Element::Subform)
-              : NULL;
+              : nullptr;
       FX_BOOL bUseAttribute = TRUE;
       if (pTemplateChosen &&
           pTemplateChosen->GetEnum(XFA_ATTRIBUTE_RestoreState) !=
               XFA_ATTRIBUTEENUM_Auto) {
         bUseAttribute = FALSE;
       }
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID, bUseAttribute)) {
-        return NULL;
+        return nullptr;
       }
     }
   }
   if (pNode) {
     pNode->SetXMLMappingNode(pXMLDocumentNode);
   }
   return pNode;
 }
 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;
+    return nullptr;
   }
   for (CFDE_XMLNode* pDatasetsNode =
            pXMLDocumentNode->GetNodeItem(CFDE_XMLNode::FirstChild);
        pDatasetsNode;
        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;
+  return nullptr;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Data(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CFDE_XMLNode* pDatasetsXMLNode = XFA_GetDataSetsFromXDP(pXMLDocumentNode);
   if (pDatasetsXMLNode) {
     CXFA_Node* pNode =
         m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataModel);
     if (!pNode) {
-      return NULL;
+      return nullptr;
     }
     pNode->SetCData(XFA_ATTRIBUTE_Name,
                     XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName);
     if (!DataLoader(pNode, pDatasetsXMLNode, FALSE)) {
-      return NULL;
+      return nullptr;
     }
     pNode->SetXMLMappingNode(pDatasetsXMLNode);
     return pNode;
   }
-  CFDE_XMLNode* pDataXMLNode = NULL;
+  CFDE_XMLNode* pDataXMLNode = nullptr;
   if (XFA_FDEExtension_MatchNodeName(
           pXMLDocumentNode, FX_WSTRC(L"data"),
           XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI,
           XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
     static_cast<CFDE_XMLElement*>(pXMLDocumentNode)
         ->RemoveAttribute(L"xmlns:xfa");
     pDataXMLNode = pXMLDocumentNode;
   } else {
     CFDE_XMLElement* pDataElement = new CFDE_XMLElement(L"xfa:data");
     CFDE_XMLNode* pParentXMLNode =
         pXMLDocumentNode->GetNodeItem(CFDE_XMLNode::Parent);
     if (pParentXMLNode) {
       pParentXMLNode->RemoveChildNode(pXMLDocumentNode);
     }
     ASSERT(pXMLDocumentNode->GetType() == FDE_XMLNODE_Element);
     if (pXMLDocumentNode->GetType() == FDE_XMLNODE_Element) {
       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;
+      return nullptr;
     }
     CFX_WideString wsLocalName;
     static_cast<CFDE_XMLElement*>(pDataXMLNode)->GetLocalTagName(wsLocalName);
     pNode->SetCData(XFA_ATTRIBUTE_Name, wsLocalName);
     if (!DataLoader(pNode, pDataXMLNode, TRUE)) {
-      return NULL;
+      return nullptr;
     }
     pNode->SetXMLMappingNode(pDataXMLNode);
     if (pDataXMLNode != pXMLDocumentNode) {
       pNode->SetFlag(XFA_NodeFlag_OwnXMLNode, false);
     }
     return pNode;
   }
-  return NULL;
+  return nullptr;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_LocaleConnectionSourceSet(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
-  CXFA_Node* pNode = NULL;
+  CXFA_Node* pNode = nullptr;
   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) {
-        return NULL;
+        return nullptr;
       }
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName);
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
-        return NULL;
+        return nullptr;
       }
     }
   } else if (ePacketID == XFA_XDPPACKET_ConnectionSet) {
     if (XFA_FDEExtension_MatchNodeName(
             pXMLDocumentNode,
             XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName,
             XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pURI,
             XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->eFlags)) {
       pNode = m_pFactory->CreateNode(XFA_XDPPACKET_ConnectionSet,
                                      XFA_Element::ConnectionSet);
       if (!pNode) {
-        return NULL;
+        return nullptr;
       }
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName);
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
-        return NULL;
+        return nullptr;
       }
     }
   } else if (ePacketID == XFA_XDPPACKET_SourceSet) {
     if (XFA_FDEExtension_MatchNodeName(
             pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName,
             XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pURI,
             XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->eFlags)) {
       pNode = m_pFactory->CreateNode(XFA_XDPPACKET_SourceSet,
                                      XFA_Element::SourceSet);
       if (!pNode) {
-        return NULL;
+        return nullptr;
       }
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName);
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
-        return NULL;
+        return nullptr;
       }
     }
   }
   if (pNode) {
     pNode->SetXMLMappingNode(pXMLDocumentNode);
   }
   return pNode;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Xdc(
     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;
+      return nullptr;
     }
     pNode->SetCData(XFA_ATTRIBUTE_Name,
                     XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName);
     pNode->SetXMLMappingNode(pXMLDocumentNode);
     return pNode;
   }
-  return NULL;
+  return nullptr;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_User(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode =
       m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_Element::Packet);
   if (!pNode) {
-    return NULL;
+    return nullptr;
   }
   CFX_WideString wsName;
   static_cast<CFDE_XMLElement*>(pXMLDocumentNode)->GetLocalTagName(wsName);
   pNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
   if (!UserPacketLoader(pNode, pXMLDocumentNode)) {
-    return NULL;
+    return nullptr;
   }
   pNode->SetXMLMappingNode(pXMLDocumentNode);
   return pNode;
 }
 CXFA_Node* CXFA_SimpleParser::UserPacketLoader(CXFA_Node* pXFANode,
                                                CFDE_XMLNode* pXMLDoc) {
   return pXFANode;
 }
 static FX_BOOL XFA_FDEExtension_IsStringAllWhitespace(CFX_WideString wsText) {
   wsText.TrimRight(L"\x20\x9\xD\xA");
@@ skipping 26 matching lines @@
             pXFANode->GetElementType(), eType, ePacketID);
         if (pPropertyInfo &&
             ((pPropertyInfo->uFlags &
               (XFA_PROPERTYFLAG_OneOf | XFA_PROPERTYFLAG_DefaultOneOf)) != 0)) {
           if (bOneOfPropertyFound) {
             break;
           }
           bOneOfPropertyFound = TRUE;
         }
         CXFA_Node* pXFAChild = m_pFactory->CreateNode(ePacketID, eType);
-        if (pXFAChild == NULL) {
-          return NULL;
-        }
-        if (ePacketID == XFA_XDPPACKET_Config) {
+        if (!pXFAChild)
+          return nullptr;
+        if (ePacketID == XFA_XDPPACKET_Config)
           pXFAChild->SetAttribute(XFA_ATTRIBUTE_Name, wsTagName.AsStringC());
-        }
+
         FX_BOOL IsNeedValue = TRUE;
         for (int32_t i = 0, count = pXMLElement->CountAttributes(); i < count;
              i++) {
           CFX_WideString wsAttrQualifiedName;
           CFX_WideString wsAttrName;
           CFX_WideString wsAttrValue;
           pXMLElement->GetAttribute(i, wsAttrQualifiedName, wsAttrValue);
           XFA_FDEExtension_GetAttributeLocalName(
               wsAttrQualifiedName.AsStringC(), wsAttrName);
           if (wsAttrName == FX_WSTRC(L"nil") &&
@@ skipping 228 matching lines @@
                 break;
               }
             }
           }
         }
         if (eNodeType == XFA_Element::DataModel) {
           eNodeType = XFA_Element::DataValue;
         }
         CXFA_Node* pXFAChild =
             m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, eNodeType);
-        if (pXFAChild == NULL) {
+        if (!pXFAChild) {
           return;
         }
         CFX_WideString wsNodeName;
         pXMLElement->GetLocalTagName(wsNodeName);
         pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeName);
         FX_BOOL bNeedValue = TRUE;
         if (1) {
           for (int32_t i = 0, count = pXMLElement->CountAttributes(); i < count;
                i++) {
             CFX_WideString wsAttrQualifiedName;
@@ skipping 19 matching lines @@
                     FX_WSTRC(L"http://www.w3.org/2001/XMLSchema-instance") ||
                 wsAttrNamespaceURI ==
                     FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/")) {
               continue;
             }
             if (0) {
               continue;
             }
             CXFA_Node* pXFAMetaData = m_pFactory->CreateNode(
                 XFA_XDPPACKET_Datasets, XFA_Element::DataValue);
-            if (pXFAMetaData == NULL) {
+            if (!pXFAMetaData) {
               return;
             }
             pXFAMetaData->SetCData(XFA_ATTRIBUTE_Name, wsAttrName);
             pXFAMetaData->SetCData(XFA_ATTRIBUTE_QualifiedName,
                                    wsAttrQualifiedName);
             pXFAMetaData->SetCData(XFA_ATTRIBUTE_Value, wsAttrValue);
             pXFAMetaData->SetEnum(XFA_ATTRIBUTE_Contains,
                                   XFA_ATTRIBUTEENUM_MetaData);
             pXFAChild->InsertChild(pXFAMetaData);
             pXFAMetaData->SetXMLMappingNode(pXMLElement);
@@ skipping 19 matching lines @@
       case FDE_XMLNODE_CharData: {
         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) {
+        if (!pXFAChild) {
           return;
         }
         pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCharData);
         pXFANode->InsertChild(pXFAChild);
         pXFAChild->SetXMLMappingNode(pXMLCharData);
         pXFAChild->SetFlag(XFA_NodeFlag_Initialized, false);
       }
         continue;
       case FDE_XMLNODE_Text: {
         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) {
+        if (!pXFAChild) {
           return;
         }
         pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsText);
         pXFANode->InsertChild(pXFAChild);
         pXFAChild->SetXMLMappingNode(pXMLText);
         pXFAChild->SetFlag(XFA_NodeFlag_Initialized, false);
       }
         continue;
       case FDE_XMLNODE_Instruction:
         continue;
@@ skipping 125 matching lines @@
       if (pXMLInstruction->GetData(1, wsData) &&
           wsData == FX_WSTRC(L"strictScoping")) {
         pXFANode->GetDocument()->SetFlag(XFA_DOCFLAG_StrictScoping, TRUE);
       }
     }
   }
 }
 void CXFA_SimpleParser::CloseParser() {
   if (m_pXMLDoc) {
     m_pXMLDoc->Release();
-    m_pXMLDoc = NULL;
+    m_pXMLDoc = nullptr;
   }
   if (m_pStream) {
     m_pStream->Release();
-    m_pStream = NULL;
+    m_pStream = nullptr;
   }
 }
 
 CXFA_DocumentParser::CXFA_DocumentParser(CXFA_FFNotify* pNotify)
-    : m_nodeParser(NULL, TRUE), m_pNotify(pNotify), m_pDocument(NULL) {}
+    : m_nodeParser(nullptr, TRUE), m_pNotify(pNotify), m_pDocument(nullptr) {}
 CXFA_DocumentParser::~CXFA_DocumentParser() {
   CloseParser();
 }
 
 void CXFA_DocumentParser::Release() {
   delete this;
 }
 int32_t CXFA_DocumentParser::StartParse(IFX_FileRead* pStream,
                                         XFA_XDPPACKET ePacketID) {
   CloseParser();
   int32_t nRetStatus = m_nodeParser.StartParse(pStream, ePacketID);
   if (nRetStatus == XFA_PARSESTATUS_Ready) {
     m_pDocument = new CXFA_Document(this);
     m_nodeParser.SetFactory(m_pDocument);
   }
   return nRetStatus;
 }
 int32_t CXFA_DocumentParser::DoParse(IFX_Pause* pPause) {
   int32_t nRetStatus = m_nodeParser.DoParse(pPause);
   if (nRetStatus >= XFA_PARSESTATUS_Done) {
     ASSERT(m_pDocument);
     m_pDocument->SetRoot(m_nodeParser.GetRootNode());
   }
   return nRetStatus;
 }
 int32_t CXFA_DocumentParser::ParseXMLData(const CFX_WideString& wsXML,
                                           CFDE_XMLNode*& pXMLNode,
                                           IFX_Pause* pPause) {
   CloseParser();
-  int32_t nRetStatus = m_nodeParser.ParseXMLData(wsXML, pXMLNode, NULL);
+  int32_t nRetStatus = m_nodeParser.ParseXMLData(wsXML, pXMLNode, nullptr);
   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,
                                            CFDE_XMLNode* pXMLNode) {
   if (!pXFANode || !pXMLNode) {
     return;
@@ skipping 115 matching lines @@
         m_pChild = m_pParent;
         iCount++;
         break;
       case FDE_XmlSyntaxResult::TargetName:
         m_pParser->GetTargetName(m_ws1);
         if (m_ws1 == FX_WSTRC(L"originalXFAVersion") ||
             m_ws1 == FX_WSTRC(L"acrobat")) {
           m_pChild = new CFDE_XMLInstruction(m_ws1);
           m_pParent->InsertChildNode(m_pChild);
         } else {
-          m_pChild = NULL;
+          m_pChild = nullptr;
         }
         m_ws1.clear();
         break;
       case FDE_XmlSyntaxResult::TagName:
         m_pParser->GetTagName(m_ws1);
         m_pChild = new CFDE_XMLElement(m_ws1);
         m_pParent->InsertChildNode(m_pChild);
         m_NodeStack.Push(m_pChild);
         m_pParent = m_pChild;
 
@@ skipping 60 matching lines @@
     }
     if (pPause && iCount > 500 && pPause->NeedToPauseNow()) {
       break;
     }
   }
   return (m_syntaxParserResult == FDE_XmlSyntaxResult::Error ||
           m_NodeStack.GetSize() != 1)
              ? -1
              : m_pParser->GetStatus();
 }