Remove NULL in xfa/

xfa/fxfa/parser/xfa_document_datamerger_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_document_datamerger_imp.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
@@ skipping 124 matching lines @@
           pXMLDataElement->SetString(L"href", wsHref);
         }
       } break;
       case XFA_Element::ChoiceList:
         defValue.GetChildValueContent(wsValue);
         if (pWidgetData->GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
           CFX_WideStringArray wsSelTextArray;
           pWidgetData->GetSelectedItemsValue(wsSelTextArray);
           int32_t iSize = wsSelTextArray.GetSize();
           if (iSize >= 1) {
-            CXFA_Node* pValue = NULL;
+            CXFA_Node* pValue = nullptr;
             for (int32_t i = 0; i < iSize; i++) {
               pValue = pDataNode->CreateSamePacketNode(XFA_Element::DataValue);
               pValue->SetCData(XFA_ATTRIBUTE_Name, L"value");
               pValue->CreateXMLMappingNode();
               pDataNode->InsertChild(pValue);
               pValue->SetCData(XFA_ATTRIBUTE_Value, wsSelTextArray[i]);
             }
           } else {
             CFDE_XMLNode* pXMLNode = pDataNode->GetXMLMappingNode();
             ASSERT(pXMLNode->GetType() == FDE_XMLNODE_Element);
             static_cast<CFDE_XMLElement*>(pXMLNode)->SetString(L"xfa:dataNode",
                                                                L"dataGroup");
           }
         } else if (!wsValue.IsEmpty()) {
           pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
           pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
         }
         break;
       case XFA_Element::CheckButton:
         defValue.GetChildValueContent(wsValue);
         if (wsValue.IsEmpty()) {
           break;
         }
         pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
         pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
         break;
       case XFA_Element::ExclGroup: {
-        CXFA_Node* pChecked = NULL;
+        CXFA_Node* pChecked = nullptr;
         CXFA_Node* pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
         for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
           if (pChild->GetElementType() != XFA_Element::Field) {
             continue;
           }
           CXFA_Node* pValue = pChild->GetChild(0, XFA_Element::Value);
           if (!pValue) {
             continue;
           }
           CXFA_Value valueChild(pValue);
@@ skipping 25 matching lines @@
         for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
           if (pChild == pChecked) {
             continue;
           }
           if (pChild->GetElementType() != XFA_Element::Field) {
             continue;
           }
           CXFA_Node* pValue = pChild->GetProperty(0, XFA_Element::Value);
           CXFA_Node* pItems = pChild->GetChild(0, XFA_Element::Items);
           CXFA_Node* pText =
-              pItems ? pItems->GetNodeItem(XFA_NODEITEM_FirstChild) : NULL;
+              pItems ? pItems->GetNodeItem(XFA_NODEITEM_FirstChild) : nullptr;
           if (pText) {
             pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
           }
           CFX_WideString wsContent;
           if (pText) {
             pText->TryContent(wsContent);
           }
           XFA_DataMerge_FormValueNode_SetChildContent(pValue, wsContent,
                                                       XFA_Element::Text);
         }
@@ skipping 103 matching lines @@
       case XFA_Element::TextEdit:
       default:
         XFA_DataMerge_FormValueNode_SetChildContent(
             defValue.GetNode(), wsNormailizeValue, XFA_Element::Text);
         break;
     }
   }
 }
 static CXFA_Node* XFA_DataMerge_GetGlobalBinding(CXFA_Document* pDocument,
                                                  uint32_t dwNameHash) {
-  CXFA_Node* pNode = NULL;
+  CXFA_Node* pNode = nullptr;
   pDocument->m_rgGlobalBinding.Lookup(dwNameHash, pNode);
   return pNode;
 }
 static void XFA_DataMerge_RegisterGlobalBinding(CXFA_Document* pDocument,
                                                 uint32_t dwNameHash,
                                                 CXFA_Node* pDataNode) {
   pDocument->m_rgGlobalBinding.SetAt(dwNameHash, pDataNode);
 }
 static void XFA_DataMerge_ClearGlobalBinding(CXFA_Document* pDocument) {
   pDocument->m_rgGlobalBinding.RemoveAll();
 }
 static CXFA_Node* XFA_DataMerge_ScopeMatchGlobalBinding(
     CXFA_Node* pDataScope,
     uint32_t dwNameHash,
     XFA_Element eMatchDataNodeType,
     FX_BOOL bUpLevel = TRUE) {
-  for (CXFA_Node *pCurDataScope = pDataScope, *pLastDataScope = NULL;
+  for (CXFA_Node *pCurDataScope = pDataScope, *pLastDataScope = nullptr;
        pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets;
        pLastDataScope = pCurDataScope,
                  pCurDataScope =
                      pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) {
     for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash);
          pDataChild;
          pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) {
       if (pDataChild == pLastDataScope ||
           (eMatchDataNodeType != XFA_Element::DataModel &&
            pDataChild->GetElementType() != eMatchDataNodeType) ||
           pDataChild->HasBindItem()) {
         continue;
       }
       return pDataChild;
     }
     for (CXFA_Node* pDataChild =
              pCurDataScope->GetFirstChildByClass(XFA_Element::DataGroup);
          pDataChild; pDataChild = pDataChild->GetNextSameClassSibling(
                          XFA_Element::DataGroup)) {
       CXFA_Node* pDataNode = XFA_DataMerge_ScopeMatchGlobalBinding(
           pDataChild, dwNameHash, eMatchDataNodeType, FALSE);
       if (pDataNode) {
         return pDataNode;
       }
     }
     if (!bUpLevel) {
       break;
     }
   }
-  return NULL;
+  return nullptr;
 }
 static CXFA_Node* XFA_DataMerge_FindGlobalDataNode(CXFA_Document* pDocument,
                                                    CFX_WideStringC wsName,
                                                    CXFA_Node* pDataScope,
                                                    XFA_Element eMatchNodeType) {
   if (wsName.IsEmpty())
     return nullptr;
 
   uint32_t dwNameHash = FX_HashCode_GetW(wsName, false);
   CXFA_Node* pBounded = XFA_DataMerge_GetGlobalBinding(pDocument, dwNameHash);
@@ skipping 47 matching lines @@
   }
   XFA_RESOLVENODE_RS rs;
   pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs, dFlags,
                                                 pTemplateNode);
   if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeAll ||
       rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeMidAll ||
       rs.nodes.GetSize() > 1) {
     return pDocument->GetNotBindNode(rs.nodes);
   }
   if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeOne) {
-    CXFA_Object* pObject = (rs.nodes.GetSize() > 0) ? rs.nodes[0] : NULL;
+    CXFA_Object* pObject = (rs.nodes.GetSize() > 0) ? rs.nodes[0] : nullptr;
     CXFA_Node* pNode = ToNode(pObject);
     if (!bForceBind && pNode && pNode->HasBindItem()) {
-      pNode = NULL;
+      pNode = nullptr;
     }
     return pNode;
   }
-  return NULL;
+  return nullptr;
 }
 CXFA_Node* XFA_DataMerge_FindFormDOMInstance(CXFA_Document* pDocument,
                                              XFA_Element eType,
                                              uint32_t dwNameHash,
                                              CXFA_Node* pFormParent) {
   CXFA_Node* pFormChild = pFormParent->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pFormChild;
        pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pFormChild->GetElementType() == eType &&
         pFormChild->GetNameHash() == dwNameHash && pFormChild->IsUnusedNode()) {
       return pFormChild;
     }
   }
-  return NULL;
+  return nullptr;
 }
 static FX_BOOL XFA_NeedGenerateForm(CXFA_Node* pTemplateChild,
                                     FX_BOOL bUseInstanceManager = TRUE) {
   XFA_Element eType = pTemplateChild->GetElementType();
   if (eType == XFA_Element::Variables) {
     return TRUE;
   }
   if (pTemplateChild->IsContainerNode()) {
     return FALSE;
   }
   if (eType == XFA_Element::Proto ||
       (bUseInstanceManager && eType == XFA_Element::Occur)) {
     return FALSE;
   }
   return TRUE;
 }
 CXFA_Node* XFA_NodeMerge_CloneOrMergeContainer(CXFA_Document* pDocument,
                                                CXFA_Node* pFormParent,
                                                CXFA_Node* pTemplateNode,
                                                FX_BOOL bRecursive,
                                                CXFA_NodeArray* pSubformArray) {
-  CXFA_Node* pExistingNode = NULL;
-  if (pSubformArray == NULL) {
+  CXFA_Node* pExistingNode = nullptr;
+  if (!pSubformArray) {
     pExistingNode = XFA_DataMerge_FindFormDOMInstance(
         pDocument, pTemplateNode->GetElementType(),
         pTemplateNode->GetNameHash(), pFormParent);
   } else if (pSubformArray->GetSize() > 0) {
     pExistingNode = pSubformArray->GetAt(0);
     pSubformArray->RemoveAt(0);
   }
   if (pExistingNode) {
     if (pSubformArray) {
       pFormParent->InsertChild(pExistingNode);
@@ skipping 11 matching lines @@
         if (XFA_NeedGenerateForm(pTemplateChild)) {
           XFA_NodeMerge_CloneOrMergeContainer(pDocument, pExistingNode,
                                               pTemplateChild, bRecursive);
         }
       }
     }
     pExistingNode->SetFlag(XFA_NodeFlag_Initialized, true);
     return pExistingNode;
   }
   CXFA_Node* pNewNode = pTemplateNode->CloneTemplateToForm(FALSE);
-  pFormParent->InsertChild(pNewNode, NULL);
+  pFormParent->InsertChild(pNewNode, nullptr);
   if (bRecursive) {
     for (CXFA_Node* pTemplateChild =
              pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
          pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                              XFA_NODEITEM_NextSibling)) {
       if (XFA_NeedGenerateForm(pTemplateChild)) {
         CXFA_Node* pNewChild = pTemplateChild->CloneTemplateToForm(TRUE);
-        pNewNode->InsertChild(pNewChild, NULL);
+        pNewNode->InsertChild(pNewChild, nullptr);
       }
     }
   }
   return pNewNode;
 }
 static CXFA_Node* XFA_NodeMerge_CloneOrMergeInstanceManager(
     CXFA_Document* pDocument,
     CXFA_Node* pFormParent,
     CXFA_Node* pTemplateNode,
     CXFA_NodeArray& subforms) {
@@ skipping 30 matching lines @@
     pExistingNode->ClearFlag(XFA_NodeFlag_UnusedNode);
     pExistingNode->SetTemplateNode(pTemplateNode);
     return pExistingNode;
   }
   CXFA_Node* pNewNode = pDocument->GetParser()->GetFactory()->CreateNode(
       XFA_XDPPACKET_Form, XFA_Element::InstanceManager);
   ASSERT(pNewNode);
   wsInstMgrNodeName =
       FX_WSTRC(L"_") + pTemplateNode->GetCData(XFA_ATTRIBUTE_Name);
   pNewNode->SetCData(XFA_ATTRIBUTE_Name, wsInstMgrNodeName);
-  pFormParent->InsertChild(pNewNode, NULL);
+  pFormParent->InsertChild(pNewNode, nullptr);
   pNewNode->SetTemplateNode(pTemplateNode);
   return pNewNode;
 }
 static CXFA_Node* XFA_DataMerge_FindMatchingDataNode(
     CXFA_Document* pDocument,
     CXFA_Node* pTemplateNode,
     CXFA_Node* pDataScope,
     FX_BOOL& bAccessedDataDOM,
     FX_BOOL bForceBind,
     CXFA_NodeIteratorTemplate<CXFA_Node,
                               CXFA_TraverseStrategy_XFAContainerNode>*
         pIterator,
     FX_BOOL& bSelfMatch,
     XFA_ATTRIBUTEENUM& eBindMatch,
     FX_BOOL bUpLevel = TRUE) {
   FX_BOOL bOwnIterator = FALSE;
   if (!pIterator) {
     bOwnIterator = TRUE;
     pIterator = new CXFA_NodeIteratorTemplate<
         CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>(pTemplateNode);
   }
-  CXFA_Node* pResult = NULL;
+  CXFA_Node* pResult = nullptr;
   for (CXFA_Node* pCurTemplateNode = pIterator->GetCurrent();
        pCurTemplateNode;) {
     XFA_Element eMatchNodeType;
     switch (pCurTemplateNode->GetElementType()) {
       case XFA_Element::Subform:
         eMatchNodeType = XFA_Element::DataGroup;
         break;
       case XFA_Element::Field: {
         eMatchNodeType = XFA_FieldIsMultiListBox(pCurTemplateNode)
                              ? XFA_Element::DataGroup
@@ skipping 118 matching lines @@
   }
 }
 static CXFA_Node* XFA_DataMerge_CopyContainer_SubformSet(
     CXFA_Document* pDocument,
     CXFA_Node* pTemplateNode,
     CXFA_Node* pFormParentNode,
     CXFA_Node* pDataScope,
     FX_BOOL bOneInstance,
     FX_BOOL bDataMerge) {
   XFA_Element eType = pTemplateNode->GetElementType();
-  CXFA_Node* pOccurNode = NULL;
-  CXFA_Node* pFirstInstance = NULL;
+  CXFA_Node* pOccurNode = nullptr;
+  CXFA_Node* pFirstInstance = nullptr;
   FX_BOOL bUseInstanceManager =
       pFormParentNode->GetElementType() != XFA_Element::Area;
-  CXFA_Node* pInstMgrNode = NULL;
+  CXFA_Node* pInstMgrNode = nullptr;
   CXFA_NodeArray subformArray;
-  CXFA_NodeArray* pSearchArray = NULL;
+  CXFA_NodeArray* pSearchArray = nullptr;
   if (!bOneInstance &&
       (eType == XFA_Element::SubformSet || eType == XFA_Element::Subform)) {
     pInstMgrNode =
         bUseInstanceManager
             ? XFA_NodeMerge_CloneOrMergeInstanceManager(
                   pDocument, pFormParentNode, pTemplateNode, subformArray)
-            : NULL;
+            : nullptr;
     if (CXFA_Node* pOccurTemplateNode =
             pTemplateNode->GetFirstChildByClass(XFA_Element::Occur)) {
       pOccurNode = pInstMgrNode
                        ? XFA_NodeMerge_CloneOrMergeContainer(
                              pDocument, pInstMgrNode, pOccurTemplateNode, FALSE)
                        : pOccurTemplateNode;
     } else if (pInstMgrNode) {
       pOccurNode = pInstMgrNode->GetFirstChildByClass(XFA_Element::Occur);
       if (pOccurNode) {
         pOccurNode->ClearFlag(XFA_NodeFlag_UnusedNode);
       }
     }
     if (pInstMgrNode) {
       pInstMgrNode->SetFlag(XFA_NodeFlag_Initialized, true);
       pSearchArray = &subformArray;
       if (pFormParentNode->GetElementType() == XFA_Element::PageArea) {
         bOneInstance = TRUE;
         if (subformArray.GetSize() < 1) {
-          pSearchArray = NULL;
+          pSearchArray = nullptr;
         }
       } else if ((pTemplateNode->GetNameHash() == 0) &&
                  (subformArray.GetSize() < 1)) {
-        pSearchArray = NULL;
+        pSearchArray = nullptr;
       }
     }
   }
   int32_t iMax = 1, iInit = 1, iMin = 1;
   if (!bOneInstance) {
     XFA_GetOccurInfo(pOccurNode, iMin, iMax, iInit);
   }
   XFA_ATTRIBUTEENUM eRelation =
       eType == XFA_Element::SubformSet
           ? pTemplateNode->GetEnum(XFA_ATTRIBUTE_Relation)
@@ skipping 78 matching lines @@
           if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
             XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
                                                 pTemplateChild, TRUE);
           } else if (pTemplateChild->IsContainerNode()) {
             bSelfMatch = FALSE;
             eBindMatch = XFA_ATTRIBUTEENUM_None;
             CXFA_Node* pDataMatch;
             if (eRelation != XFA_ATTRIBUTEENUM_Ordered &&
                 (pDataMatch = XFA_DataMerge_FindMatchingDataNode(
                      pDocument, pTemplateChild, pDataScope, bAccessedDataDOM,
-                     FALSE, NULL, bSelfMatch, eBindMatch)) != nullptr) {
+                     FALSE, nullptr, bSelfMatch, eBindMatch)) != nullptr) {
               XFA_DataMerge_RecurseRecord sNewRecord = {pTemplateChild,
                                                         pDataMatch};
               if (bSelfMatch) {
                 rgItemMatchList.InsertAt(0, sNewRecord);
               } else {
                 rgItemMatchList.Add(sNewRecord);
               }
             } else {
               rgItemUnmatchList.Add(pTemplateChild);
             }
@@ skipping 53 matching lines @@
         if (iLimit < iMin) {
           iLimit = iInit;
         }
       }
       for (; (iLimit < 0 || iCurRepeatIndex < iLimit); iCurRepeatIndex++) {
         if (pInstMgrNode) {
           if (pSearchArray && pSearchArray->GetSize() < 1) {
             if (pTemplateNode->GetNameHash() != 0) {
               break;
             }
-            pSearchArray = NULL;
+            pSearchArray = nullptr;
           }
         } else if (!XFA_DataMerge_FindFormDOMInstance(
                        pDocument, pTemplateNode->GetElementType(),
                        pTemplateNode->GetNameHash(), pFormParentNode)) {
           break;
         }
         CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer(
             pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
         ASSERT(pSubformNode);
         if (!pFirstInstance) {
@@ skipping 55 matching lines @@
            pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
        pTemplateChildNode; pTemplateChildNode = pTemplateChildNode->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
     if (XFA_NeedGenerateForm(pTemplateChildNode)) {
       XFA_NodeMerge_CloneOrMergeContainer(pDocument, pFieldNode,
                                           pTemplateChildNode, TRUE);
     } else if (pTemplateNode->GetElementType() == XFA_Element::ExclGroup &&
                pTemplateChildNode->IsContainerNode()) {
       if (pTemplateChildNode->GetElementType() == XFA_Element::Field) {
         XFA_DataMerge_CopyContainer_Field(pDocument, pTemplateChildNode,
-                                          pFieldNode, NULL, FALSE);
+                                          pFieldNode, nullptr, FALSE);
       }
     }
   }
   if (bDataMerge) {
     FX_BOOL bAccessedDataDOM = FALSE;
     FX_BOOL bSelfMatch = FALSE;
     XFA_ATTRIBUTEENUM eBindMatch;
     CXFA_Node* pDataNode = XFA_DataMerge_FindMatchingDataNode(
-        pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, TRUE, NULL,
+        pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, TRUE, nullptr,
         bSelfMatch, eBindMatch, bUpLevel);
     if (pDataNode) {
       XFA_DataMerge_CreateDataBinding(pFieldNode, pDataNode);
     }
   } else {
     XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFieldNode);
   }
   return pFieldNode;
 }
 CXFA_Node* CXFA_Document::DataMerge_CopyContainer(CXFA_Node* pTemplateNode,
@@ skipping 16 matching lines @@
       return XFA_DataMerge_CopyContainer_Field(
           this, pTemplateNode, pFormNode, pDataScope, bDataMerge, bUpLevel);
     case XFA_Element::PageSet:
       break;
     case XFA_Element::Variables:
       break;
     default:
       ASSERT(FALSE);
       break;
   }
-  return NULL;
+  return nullptr;
 }
 
 static void XFA_DataMerge_UpdateBindingRelations(CXFA_Document* pDocument,
                                                  CXFA_Node* pFormNode,
                                                  CXFA_Node* pDataScope,
                                                  FX_BOOL bDataRef,
                                                  FX_BOOL bParentDataRef) {
   FX_BOOL bMatchRef = TRUE;
   XFA_Element eType = pFormNode->GetElementType();
   CXFA_Node* pDataNode = pFormNode->GetBindData();
   if (eType == XFA_Element::Subform || eType == XFA_Element::ExclGroup ||
       eType == XFA_Element::Field) {
     CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode();
     CXFA_Node* pTemplateNodeBind =
         pTemplateNode ? pTemplateNode->GetFirstChildByClass(XFA_Element::Bind)
-                      : NULL;
+                      : nullptr;
     XFA_ATTRIBUTEENUM eMatch =
         pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match)
                           : XFA_ATTRIBUTEENUM_Once;
     switch (eMatch) {
       case XFA_ATTRIBUTEENUM_None:
         if (!bDataRef || bParentDataRef) {
           XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode);
         }
         break;
       case XFA_ATTRIBUTEENUM_Once:
@@ skipping 60 matching lines @@
         bMatchRef = bDataRef;
         bParentDataRef = TRUE;
         if (!pDataNode && bDataRef) {
           CFX_WideStringC wsRef =
               pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref);
           uint32_t dFlags =
               XFA_RESOLVENODE_Children | XFA_RESOLVENODE_CreateNode;
           XFA_RESOLVENODE_RS rs;
           pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs,
                                                         dFlags, pTemplateNode);
-          CXFA_Object* pObject = (rs.nodes.GetSize() > 0) ? rs.nodes[0] : NULL;
+          CXFA_Object* pObject =
+              (rs.nodes.GetSize() > 0) ? rs.nodes[0] : nullptr;
           pDataNode = ToNode(pObject);
           if (pDataNode) {
             XFA_DataMerge_CreateDataBinding(
                 pFormNode, pDataNode,
                 rs.dwFlags == XFA_RESOVENODE_RSTYPE_ExistNodes);
           } else {
             XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFormNode);
           }
         }
       } break;
@@ skipping 57 matching lines @@
   if (!pDatasetsRoot) {
     CFDE_XMLElement* pDatasetsXMLNode = new CFDE_XMLElement(L"xfa:datasets");
     pDatasetsXMLNode->SetString(L"xmlns:xfa",
                                 L"http://www.xfa.org/schema/xfa-data/1.0/");
     pDatasetsRoot = CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataModel);
     pDatasetsRoot->SetCData(XFA_ATTRIBUTE_Name, L"datasets");
     m_pRootNode->GetXMLMappingNode()->InsertChildNode(pDatasetsXMLNode);
     m_pRootNode->InsertChild(pDatasetsRoot);
     pDatasetsRoot->SetXMLMappingNode(pDatasetsXMLNode);
   }
-  CXFA_Node *pDataRoot = NULL, *pDDRoot = NULL;
+  CXFA_Node *pDataRoot = nullptr, *pDDRoot = nullptr;
   CFX_WideString wsDatasetsURI;
   pDatasetsRoot->TryNamespace(wsDatasetsURI);
   for (CXFA_Node* pChildNode =
            pDatasetsRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
        pChildNode;
        pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pChildNode->GetElementType() != XFA_Element::DataGroup) {
       continue;
     }
     CFX_WideString wsNamespaceURI;
@@ skipping 26 matching lines @@
   }
   CXFA_Node* pDataTopLevel =
       pDataRoot->GetFirstChildByClass(XFA_Element::DataGroup);
   uint32_t dwNameHash = pDataTopLevel ? pDataTopLevel->GetNameHash() : 0;
   CXFA_Node* pTemplateRoot =
       m_pRootNode->GetFirstChildByClass(XFA_Element::Template);
   if (!pTemplateRoot) {
     return;
   }
   CXFA_Node* pTemplateChosen =
-      dwNameHash != 0 ? pTemplateRoot->GetFirstChildByName(dwNameHash) : NULL;
+      dwNameHash != 0 ? pTemplateRoot->GetFirstChildByName(dwNameHash)
+                      : nullptr;
   if (!pTemplateChosen ||
       pTemplateChosen->GetElementType() != XFA_Element::Subform) {
     pTemplateChosen = pTemplateRoot->GetFirstChildByClass(XFA_Element::Subform);
   }
   if (!pTemplateChosen) {
     return;
   }
   CXFA_Node* pFormRoot = m_pRootNode->GetFirstChildByClass(XFA_Element::Form);
   FX_BOOL bEmptyForm = FALSE;
   if (!pFormRoot) {
     bEmptyForm = TRUE;
     pFormRoot = CreateNode(XFA_XDPPACKET_Form, XFA_Element::Form);
     ASSERT(pFormRoot);
     pFormRoot->SetCData(XFA_ATTRIBUTE_Name, L"form");
-    m_pRootNode->InsertChild(pFormRoot, NULL);
+    m_pRootNode->InsertChild(pFormRoot, nullptr);
   } else {
     CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
         sIterator(pFormRoot);
     for (CXFA_Node* pNode = sIterator.MoveToNext(); pNode;
          pNode = sIterator.MoveToNext()) {
       pNode->SetFlag(XFA_NodeFlag_UnusedNode, true);
     }
   }
   CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
       this, pFormRoot, pTemplateChosen, FALSE);
@@ skipping 59 matching lines @@
       }
     }
   }
 }
 void CXFA_Document::DoDataRemerge(FX_BOOL bDoDataMerge) {
   CXFA_Node* pFormRoot = ToNode(GetXFAObject(XFA_HASHCODE_Form));
   if (pFormRoot) {
     while (CXFA_Node* pNode = pFormRoot->GetNodeItem(XFA_NODEITEM_FirstChild)) {
       pFormRoot->RemoveChild(pNode);
     }
-    pFormRoot->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
+    pFormRoot->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
   }
   XFA_DataMerge_ClearGlobalBinding(this);
   if (bDoDataMerge) {
     DoDataMerge();
   }
   CXFA_LayoutProcessor* pLayoutProcessor = GetLayoutProcessor();
   pLayoutProcessor->SetForceReLayout(TRUE);
 }