Remove NULL in xfa/

xfa/fxfa/parser/xfa_script_nodehelper.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_script_nodehelper.h"
 
 #include "core/fxcrt/include/fx_ext.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"
 #include "xfa/fxfa/parser/xfa_script_imp.h"
 #include "xfa/fxfa/parser/xfa_utils.h"
 
 CXFA_NodeHelper::CXFA_NodeHelper()
     : m_eLastCreateType(XFA_Element::DataValue),
-      m_pCreateParent(NULL),
+      m_pCreateParent(nullptr),
       m_iCreateCount(0),
       m_iCreateFlag(XFA_RESOLVENODE_RSTYPE_CreateNodeOne),
       m_iCurAllStart(-1),
-      m_pAllStartParent(NULL) {}
+      m_pAllStartParent(nullptr) {}
 
 CXFA_NodeHelper::~CXFA_NodeHelper() {}
 
 CXFA_Node* CXFA_NodeHelper::XFA_ResolveNodes_GetOneChild(
     CXFA_Node* parent,
     const FX_WCHAR* pwsName,
     FX_BOOL bIsClassName) {
-  if (parent == NULL) {
-    return NULL;
+  if (!parent) {
+    return nullptr;
   }
   CXFA_NodeArray siblings;
   uint32_t uNameHash = FX_HashCode_GetW(CFX_WideStringC(pwsName), false);
   XFA_NodeAcc_TraverseAnySiblings(parent, uNameHash, &siblings, bIsClassName);
   if (siblings.GetSize() == 0) {
-    return NULL;
+    return nullptr;
   }
   return siblings[0];
 }
 
 int32_t CXFA_NodeHelper::XFA_CountSiblings(CXFA_Node* pNode,
                                            XFA_LOGIC_TYPE eLogicType,
                                            CXFA_NodeArray* pSiblings,
                                            FX_BOOL bIsClassName) {
   if (!pNode)
     return 0;
   CXFA_Node* parent =
       XFA_ResolveNodes_GetParent(pNode, XFA_LOGIC_NoTransparent);
   if (!parent)
     return 0;
   const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
       parent->GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN);
   if (!pProperty && eLogicType == XFA_LOGIC_Transparent) {
     parent = XFA_ResolveNodes_GetParent(pNode, XFA_LOGIC_Transparent);
-    if (parent == NULL) {
+    if (!parent) {
       return 0;
     }
   }
   if (bIsClassName) {
     return XFA_NodeAcc_TraverseSiblings(parent, pNode->GetClassHashCode(),
                                         pSiblings, eLogicType, bIsClassName);
   } else {
     return XFA_NodeAcc_TraverseSiblings(parent, pNode->GetNameHash(), pSiblings,
                                         eLogicType, bIsClassName);
   }
 }
 
 int32_t CXFA_NodeHelper::XFA_NodeAcc_TraverseAnySiblings(
     CXFA_Node* parent,
     uint32_t dNameHash,
     CXFA_NodeArray* pSiblings,
     FX_BOOL bIsClassName) {
-  if (parent == NULL || pSiblings == NULL) {
+  if (!parent || !pSiblings) {
     return 0;
   }
   int32_t nCount = 0;
   int32_t i = 0;
   CXFA_NodeArray properties;
   parent->GetNodeList(properties, XFA_NODEFILTER_Properties);
   int32_t nProperties = properties.GetSize();
   for (i = 0; i < nProperties; ++i) {
     CXFA_Node* child = properties[i];
     if (bIsClassName) {
@@ skipping 41 matching lines @@
   }
   return nCount;
 }
 
 int32_t CXFA_NodeHelper::XFA_NodeAcc_TraverseSiblings(CXFA_Node* parent,
                                                       uint32_t dNameHash,
                                                       CXFA_NodeArray* pSiblings,
                                                       XFA_LOGIC_TYPE eLogicType,
                                                       FX_BOOL bIsClassName,
                                                       FX_BOOL bIsFindProperty) {
-  if (parent == NULL || pSiblings == NULL) {
+  if (!parent || !pSiblings) {
     return 0;
   }
   int32_t nCount = 0;
   int32_t i = 0;
   if (bIsFindProperty) {
     CXFA_NodeArray properties;
     parent->GetNodeList(properties, XFA_NODEFILTER_Properties);
     int32_t nProperties = properties.GetSize();
     for (i = 0; i < nProperties; ++i) {
       CXFA_Node* child = properties[i];
@@ skipping 54 matching lines @@
                                              eLogicType, bIsClassName, FALSE);
     }
   }
   return nCount;
 }
 
 CXFA_Node* CXFA_NodeHelper::XFA_ResolveNodes_GetParent(
     CXFA_Node* pNode,
     XFA_LOGIC_TYPE eLogicType) {
   if (!pNode) {
-    return NULL;
+    return nullptr;
   }
   if (eLogicType == XFA_LOGIC_NoTransparent) {
     return pNode->GetNodeItem(XFA_NODEITEM_Parent);
   }
   CXFA_Node* parent;
   CXFA_Node* node = pNode;
   while (TRUE) {
     parent = XFA_ResolveNodes_GetParent(node);
-    if (parent == NULL) {
+    if (!parent) {
       break;
     }
     XFA_Element parentType = parent->GetElementType();
     if ((!parent->IsUnnamed() && parentType != XFA_Element::SubformSet) ||
         parentType == XFA_Element::Variables) {
       break;
     }
     node = parent;
   }
   return parent;
 }
 
 int32_t CXFA_NodeHelper::XFA_GetIndex(CXFA_Node* pNode,
                                       XFA_LOGIC_TYPE eLogicType,
                                       FX_BOOL bIsProperty,
                                       FX_BOOL bIsClassIndex) {
   CXFA_Node* parent =
       XFA_ResolveNodes_GetParent(pNode, XFA_LOGIC_NoTransparent);
-  if (parent == NULL) {
+  if (!parent) {
     return 0;
   }
   if (!bIsProperty && eLogicType == XFA_LOGIC_Transparent) {
     parent = XFA_ResolveNodes_GetParent(pNode, XFA_LOGIC_Transparent);
-    if (parent == NULL) {
+    if (!parent) {
       return 0;
     }
   }
   uint32_t dwHashName = pNode->GetNameHash();
   if (bIsClassIndex) {
     dwHashName = pNode->GetClassHashCode();
   }
   CXFA_NodeArray siblings;
   int32_t iSize = XFA_NodeAcc_TraverseSiblings(parent, dwHashName, &siblings,
                                                eLogicType, bIsClassIndex);
@@ skipping 37 matching lines @@
                   XFA_GetIndex(refNode, eLogicType, bIsProperty, TRUE));
     return;
   }
   ws = refNode->GetCData(XFA_ATTRIBUTE_Name);
   ws.Replace(L".", L"\\.");
   wsName.Format(L"%s[%d]", ws.c_str(),
                 XFA_GetIndex(refNode, eLogicType, bIsProperty, FALSE));
 }
 
 FX_BOOL CXFA_NodeHelper::XFA_NodeIsTransparent(CXFA_Node* refNode) {
-  if (refNode == NULL) {
+  if (!refNode) {
     return FALSE;
   }
   XFA_Element refNodeType = refNode->GetElementType();
   if ((refNode->IsUnnamed() && refNode->IsContainerNode()) ||
       refNodeType == XFA_Element::SubformSet ||
       refNodeType == XFA_Element::Area || refNodeType == XFA_Element::Proto) {
     return TRUE;
   }
   return FALSE;
 }
@@ skipping 35 matching lines @@
     return TRUE;
   }
   return FALSE;
 }
 
 FX_BOOL CXFA_NodeHelper::XFA_ResolveNodes_CreateNode(
     CFX_WideString wsName,
     CFX_WideString wsCondition,
     FX_BOOL bLastNode,
     CXFA_ScriptContext* pScriptContext) {
-  if (m_pCreateParent == NULL) {
+  if (!m_pCreateParent) {
     return FALSE;
   }
   FX_BOOL bIsClassName = FALSE;
   FX_BOOL bResult = FALSE;
   if (wsName.GetAt(0) == '!') {
     wsName = wsName.Right(wsName.GetLength() - 1);
     m_pCreateParent = ToNode(
         pScriptContext->GetDocument()->GetXFAObject(XFA_HASHCODE_Datasets));
   }
   if (wsName.GetAt(0) == '#') {
@@ skipping 30 matching lines @@
         pNewNode->CreateXMLMappingNode();
         m_pCreateParent->InsertChild(pNewNode);
         if (iIndex == m_iCreateCount - 1) {
           m_pCreateParent = pNewNode;
         }
         bResult = TRUE;
       }
     }
   }
   if (!bResult) {
-    m_pCreateParent = NULL;
+    m_pCreateParent = nullptr;
   }
   return bResult;
 }
 
 void CXFA_NodeHelper::XFA_SetCreateNodeType(CXFA_Node* refNode) {
-  if (refNode == NULL) {
+  if (!refNode) {
     return;
   }
   if (refNode->GetElementType() == XFA_Element::Subform) {
     m_eLastCreateType = XFA_Element::DataGroup;
   } else if (refNode->GetElementType() == XFA_Element::Field) {
     m_eLastCreateType = XFA_FieldIsMultiListBox(refNode)
                             ? XFA_Element::DataGroup
                             : XFA_Element::DataValue;
   } else if (refNode->GetElementType() == XFA_Element::ExclGroup) {
     m_eLastCreateType = XFA_Element::DataValue;
   }
 }
 
 FX_BOOL CXFA_NodeHelper::XFA_NodeIsProperty(CXFA_Node* refNode) {
   CXFA_Node* parent =
       XFA_ResolveNodes_GetParent(refNode, XFA_LOGIC_NoTransparent);
   return parent && refNode &&
          XFA_GetPropertyOfElement(parent->GetElementType(),
                                   refNode->GetElementType(),
                                   XFA_XDPPACKET_UNKNOWN);
 }