Get rid of most instance of 'foo == NULL'

core/src/fpdfdoc/doc_form.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 "core/include/fpdfdoc/fpdf_doc.h"
 #include "doc_utils.h"
 
 const int nMaxRecursion = 32;
@@ skipping 77 matching lines @@
 CFieldTree::CFieldTree() {
   m_Root.parent = NULL;
   m_Root.field_ptr = NULL;
 }
 CFieldTree::~CFieldTree() {
   RemoveAll();
 }
 CFieldTree::_Node* CFieldTree::AddChild(_Node* pParent,
                                         const CFX_WideString& short_name,
                                         CPDF_FormField* field_ptr) {
-  if (pParent == NULL) {
+  if (!pParent) {
     return NULL;
   }
   _Node* pNode = new _Node;
   pNode->parent = pParent;
   pNode->short_name = short_name;
   pNode->field_ptr = field_ptr;
   pParent->children.Add(pNode);
   return pNode;
 }
 void CFieldTree::RemoveNode(_Node* pNode, int nLevel) {
   if (!pNode) {
     return;
   }
   if (nLevel <= nMaxRecursion) {
     for (int i = 0; i < pNode->children.GetSize(); i++) {
       RemoveNode(pNode->children[i], nLevel + 1);
     }
   }
   delete pNode;
 }
 CFieldTree::_Node* CFieldTree::_Lookup(_Node* pParent,
                                        const CFX_WideString& short_name) {
-  if (pParent == NULL) {
+  if (!pParent) {
     return NULL;
   }
   for (int i = 0; i < pParent->children.GetSize(); i++) {
     _Node* pNode = pParent->children[i];
     if (pNode->short_name.GetLength() == short_name.GetLength() &&
         FXSYS_memcmp(pNode->short_name.c_str(), short_name.c_str(),
                      short_name.GetLength() * sizeof(FX_WCHAR)) == 0) {
       return pNode;
     }
   }
@@ skipping 11 matching lines @@
   }
   CFieldNameExtractor name_extractor(full_name);
   const FX_WCHAR* pName;
   FX_STRSIZE nLength;
   name_extractor.GetNext(pName, nLength);
   _Node *pNode = &m_Root, *pLast = NULL;
   while (nLength > 0) {
     pLast = pNode;
     CFX_WideString name = CFX_WideString(pName, nLength);
     pNode = _Lookup(pLast, name);
-    if (pNode == NULL) {
+    if (!pNode) {
       pNode = AddChild(pLast, name, NULL);
     }
     name_extractor.GetNext(pName, nLength);
   }
   if (pNode != &m_Root) {
     pNode->field_ptr = field_ptr;
   }
 }
 CPDF_FormField* CFieldTree::GetField(const CFX_WideString& full_name) {
   if (full_name == L"") {
@@ skipping 126 matching lines @@
     while (m < iMinLen && m < iCount) {
       csTmp += csStr[m++];
     }
     while (m < iMinLen) {
       csTmp += '0' + m % 10;
       m++;
     }
   } else {
     m = iCount;
   }
-  if (pResDict == NULL) {
+  if (!pResDict) {
     return csTmp;
   }
   CPDF_Dictionary* pDict = pResDict->GetDict(csType);
-  if (pDict == NULL) {
+  if (!pDict) {
     return csTmp;
   }
   int num = 0;
   CFX_ByteString bsNum;
   while (TRUE) {
     if (!pDict->KeyExist(csTmp + bsNum)) {
       return csTmp + bsNum;
     }
     if (m < iCount) {
       csTmp += csStr[m++];
@@ skipping 214 matching lines @@
     for (int i = csSub.GetLength() - 1; i > -1; i--) {
       if (csSub[i] == L' ' || csSub[i] == L'.') {
         csSub.SetAt(i, L'\0');
       } else {
         break;
       }
     }
     FX_DWORD dwCount = m_pFieldTree->m_Root.CountFields();
     for (FX_DWORD m = 0; m < dwCount; m++) {
       CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(m);
-      if (pField == NULL) {
+      if (!pField) {
         continue;
       }
       if (pField == pExcludedField) {
         if (pExcludedControl) {
           if (pField->CountControls() < 2) {
             continue;
           }
         } else {
           continue;
         }
@@ skipping 23 matching lines @@
   }
   csNewFieldName = csSub;
   return TRUE;
 }
 FX_BOOL CPDF_InterForm::ValidateFieldName(CFX_WideString& csNewFieldName,
                                           int iType) {
   return ValidateFieldName(csNewFieldName, iType, NULL, NULL);
 }
 FX_BOOL CPDF_InterForm::ValidateFieldName(const CPDF_FormField* pField,
                                           CFX_WideString& csNewFieldName) {
-  if (pField == NULL || csNewFieldName.IsEmpty()) {
-    return FALSE;
-  }
-  return ValidateFieldName(
-      csNewFieldName, ((CPDF_FormField*)pField)->GetFieldType(), pField, NULL);
+  return pField && !csNewFieldName.IsEmpty() &&
+         ValidateFieldName(csNewFieldName,
+                           ((CPDF_FormField*)pField)->GetFieldType(), pField,
+                           NULL);
 }
 FX_BOOL CPDF_InterForm::ValidateFieldName(const CPDF_FormControl* pControl,
                                           CFX_WideString& csNewFieldName) {
-  if (pControl == NULL || csNewFieldName.IsEmpty()) {
+  if (!pControl || csNewFieldName.IsEmpty()) {
     return FALSE;
   }
   CPDF_FormField* pField = ((CPDF_FormControl*)pControl)->GetField();
   return ValidateFieldName(csNewFieldName, pField->GetFieldType(), pField,
                            pControl);
 }
 int CPDF_InterForm::CompareFieldName(const CFX_ByteString& name1,
                                      const CFX_ByteString& name2) {
   const FX_CHAR* ptr1 = name1;
   const FX_CHAR* ptr2 = name2;
@@ skipping 29 matching lines @@
   if (i == name2.GetLength()) {
     return 3;
   }
   return 0;
 }
 FX_DWORD CPDF_InterForm::CountFields(const CFX_WideString& csFieldName) {
   if (csFieldName.IsEmpty()) {
     return (FX_DWORD)m_pFieldTree->m_Root.CountFields();
   }
   CFieldTree::_Node* pNode = m_pFieldTree->FindNode(csFieldName);
-  if (pNode == NULL) {
-    return 0;
-  }
-  return pNode->CountFields();
+  return pNode ? pNode->CountFields() : 0;
 }
 CPDF_FormField* CPDF_InterForm::GetField(FX_DWORD index,
                                          const CFX_WideString& csFieldName) {
   if (csFieldName == L"") {
     return m_pFieldTree->m_Root.GetField(index);
   }
   CFieldTree::_Node* pNode = m_pFieldTree->FindNode(csFieldName);
-  if (pNode == NULL) {
-    return NULL;
-  }
-  return pNode->GetField(index);
+  return pNode ? pNode->GetField(index) : nullptr;
 }
 void CPDF_InterForm::GetAllFieldNames(CFX_WideStringArray& allFieldNames) {
   allFieldNames.RemoveAll();
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; i++) {
     CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
     if (pField) {
       CFX_WideString full_name = GetFullName(pField->GetFieldDict());
       allFieldNames.Add(full_name);
     }
   }
 }
 
 CPDF_FormField* CPDF_InterForm::GetFieldByDict(
     CPDF_Dictionary* pFieldDict) const {
-  if (pFieldDict == NULL) {
+  if (!pFieldDict) {
     return NULL;
   }
   CFX_WideString csWName = GetFullName(pFieldDict);
   return m_pFieldTree->GetField(csWName);
 }
 
 CPDF_FormControl* CPDF_InterForm::GetControlAtPoint(CPDF_Page* pPage,
                                                     FX_FLOAT pdf_x,
                                                     FX_FLOAT pdf_y,
                                                     int* z_order) const {
@@ skipping 23 matching lines @@
   return nullptr;
 }
 
 CPDF_FormControl* CPDF_InterForm::GetControlByDict(
     const CPDF_Dictionary* pWidgetDict) const {
   const auto it = m_ControlMap.find(pWidgetDict);
   return it != m_ControlMap.end() ? it->second : nullptr;
 }
 
 FX_BOOL CPDF_InterForm::NeedConstructAP() {
-  if (m_pFormDict == NULL) {
-    return FALSE;
-  }
-  return m_pFormDict->GetBoolean("NeedAppearances");
+  return m_pFormDict && m_pFormDict->GetBoolean("NeedAppearances");
 }
 void CPDF_InterForm::NeedConstructAP(FX_BOOL bNeedAP) {
-  if (m_pFormDict == NULL) {
+  if (!m_pFormDict) {
     InitInterFormDict(m_pFormDict, m_pDocument);
   }
   m_pFormDict->SetAtBoolean("NeedAppearances", bNeedAP);
   m_bGenerateAP = bNeedAP;
 }
 int CPDF_InterForm::CountFieldsInCalculationOrder() {
-  if (m_pFormDict == NULL) {
+  if (!m_pFormDict) {
     return 0;
   }
   CPDF_Array* pArray = m_pFormDict->GetArray("CO");
-  if (pArray == NULL) {
-    return 0;
-  }
-  return pArray->GetCount();
+  return pArray ? pArray->GetCount() : 0;
 }
 CPDF_FormField* CPDF_InterForm::GetFieldInCalculationOrder(int index) {
-  if (m_pFormDict == NULL || index < 0) {
+  if (!m_pFormDict || index < 0) {
     return NULL;
   }
   CPDF_Array* pArray = m_pFormDict->GetArray("CO");
-  if (pArray == NULL) {
+  if (!pArray) {
     return NULL;
   }
   if (CPDF_Dictionary* pElement =
           ToDictionary(pArray->GetElementValue(index))) {
     return GetFieldByDict(pElement);
   }
   return NULL;
 }
 int CPDF_InterForm::FindFieldInCalculationOrder(const CPDF_FormField* pField) {
-  if (m_pFormDict == NULL || pField == NULL) {
+  if (!m_pFormDict || !pField) {
     return -1;
   }
   CPDF_Array* pArray = m_pFormDict->GetArray("CO");
-  if (pArray == NULL) {
+  if (!pArray) {
     return -1;
   }
   for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
     CPDF_Object* pElement = pArray->GetElementValue(i);
     if (pElement == pField->m_pDict) {
       return i;
     }
   }
   return -1;
 }
@@ skipping 45 matching lines @@
 void CPDF_InterForm::RemoveFormFont(const CPDF_Font* pFont) {
   m_bUpdated = TRUE;
   RemoveInterFormFont(m_pFormDict, pFont);
 }
 void CPDF_InterForm::RemoveFormFont(CFX_ByteString csNameTag) {
   m_bUpdated = TRUE;
   RemoveInterFormFont(m_pFormDict, csNameTag);
 }
 CPDF_DefaultAppearance CPDF_InterForm::GetDefaultAppearance() {
   CFX_ByteString csDA;
-  if (m_pFormDict == NULL) {
+  if (!m_pFormDict) {
     return csDA;
   }
   csDA = m_pFormDict->GetString("DA");
   return csDA;
 }
 CPDF_Font* CPDF_InterForm::GetDefaultFormFont() {
   return GetDefaultInterFormFont(m_pFormDict, m_pDocument);
 }
 int CPDF_InterForm::GetFormAlignment() {
-  if (m_pFormDict == NULL) {
-    return 0;
-  }
-  return m_pFormDict->GetInteger("Q", 0);
+  return m_pFormDict ? m_pFormDict->GetInteger("Q", 0) : 0;
 }
 
 bool CPDF_InterForm::ResetForm(const std::vector<CPDF_FormField*>& fields,
                                bool bIncludeOrExclude,
                                bool bNotify) {
   if (bNotify && m_pFormNotify && m_pFormNotify->BeforeFormReset(this) < 0)
     return false;
 
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; ++i) {
@@ skipping 24 matching lines @@
   }
   if (bNotify && m_pFormNotify)
     m_pFormNotify->AfterFormReset(this);
   return true;
 }
 
 void CPDF_InterForm::LoadField(CPDF_Dictionary* pFieldDict, int nLevel) {
   if (nLevel > nMaxRecursion) {
     return;
   }
-  if (pFieldDict == NULL) {
+  if (!pFieldDict) {
     return;
   }
   FX_DWORD dwParentObjNum = pFieldDict->GetObjNum();
   CPDF_Array* pKids = pFieldDict->GetArray("Kids");
   if (!pKids) {
     AddTerminalField(pFieldDict);
     return;
   }
   CPDF_Dictionary* pFirstKid = pKids->GetDict(0);
-  if (pFirstKid == NULL) {
+  if (!pFirstKid) {
     return;
   }
   if (pFirstKid->KeyExist("T") || pFirstKid->KeyExist("Kids")) {
     for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
       CPDF_Dictionary* pChildDict = pKids->GetDict(i);
       if (pChildDict) {
         if (pChildDict->GetObjNum() != dwParentObjNum) {
           LoadField(pChildDict, nLevel + 1);
         }
       }
     }
   } else {
     AddTerminalField(pFieldDict);
   }
 }
 FX_BOOL CPDF_InterForm::HasXFAForm() const {
   return m_pFormDict && m_pFormDict->GetArray("XFA");
 }
 void CPDF_InterForm::FixPageFields(const CPDF_Page* pPage) {
   CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
-  if (pPageDict == NULL) {
+  if (!pPageDict) {
     return;
   }
   CPDF_Array* pAnnots = pPageDict->GetArray("Annots");
-  if (pAnnots == NULL) {
+  if (!pAnnots) {
     return;
   }
   int iAnnotCount = pAnnots->GetCount();
   for (int i = 0; i < iAnnotCount; i++) {
     CPDF_Dictionary* pAnnot = pAnnots->GetDict(i);
     if (pAnnot && pAnnot->GetString("Subtype") == "Widget") {
       LoadField(pAnnot);
     }
   }
 }
 CPDF_FormField* CPDF_InterForm::AddTerminalField(CPDF_Dictionary* pFieldDict) {
   if (!pFieldDict->KeyExist("T")) {
     return NULL;
   }
   CPDF_Dictionary* pDict = pFieldDict;
   CFX_WideString csWName = GetFullName(pFieldDict);
   if (csWName.IsEmpty()) {
     return NULL;
   }
   CPDF_FormField* pField = NULL;
   pField = m_pFieldTree->GetField(csWName);
-  if (pField == NULL) {
+  if (!pField) {
     CPDF_Dictionary* pParent = pFieldDict;
     if (!pFieldDict->KeyExist("T") &&
         pFieldDict->GetString("Subtype") == "Widget") {
       pParent = pFieldDict->GetDict("Parent");
       if (!pParent) {
         pParent = pFieldDict;
       }
     }
     if (pParent && pParent != pFieldDict && !pParent->KeyExist("FT")) {
       if (pFieldDict->KeyExist("FT")) {
@@ skipping 14 matching lines @@
     if (ToReference(pTObj)) {
       CPDF_Object* pClone = pTObj->Clone(TRUE);
       if (pClone)
         pDict->SetAt("T", pClone);
       else
         pDict->SetAtName("T", "");
     }
     m_pFieldTree->SetField(csWName, pField);
   }
   CPDF_Array* pKids = pFieldDict->GetArray("Kids");
-  if (pKids == NULL) {
+  if (!pKids) {
     if (pFieldDict->GetString("Subtype") == "Widget") {
       AddControl(pField, pFieldDict);
     }
   } else {
     for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
       CPDF_Dictionary* pKid = pKids->GetDict(i);
-      if (pKid == NULL) {
+      if (!pKid) {
         continue;
       }
       if (pKid->GetString("Subtype") != "Widget") {
         continue;
       }
       AddControl(pField, pKid);
     }
   }
   return pField;
 }
@@ skipping 52 matching lines @@
     fields.push_back(m_pFieldTree->m_Root.GetField(i));
   return ExportToFDF(pdf_path, fields, true, bSimpleFileSpec);
 }
 
 CFDF_Document* CPDF_InterForm::ExportToFDF(
     const CFX_WideStringC& pdf_path,
     const std::vector<CPDF_FormField*>& fields,
     bool bIncludeOrExclude,
     bool bSimpleFileSpec) const {
   CFDF_Document* pDoc = CFDF_Document::CreateNewDoc();
-  if (pDoc == NULL) {
+  if (!pDoc) {
     return NULL;
   }
   CPDF_Dictionary* pMainDict = pDoc->GetRoot()->GetDict("FDF");
   if (!pdf_path.IsEmpty()) {
     if (bSimpleFileSpec) {
       CFX_WideString wsFilePath = FILESPEC_EncodeFileName(pdf_path);
       pMainDict->SetAtString("F", CFX_ByteString::FromUnicode(wsFilePath));
       pMainDict->SetAtString("UF", PDF_EncodeText(wsFilePath));
     } else {
       CPDF_FileSpec filespec;
       filespec.SetFileName(pdf_path);
       pMainDict->SetAt("F", static_cast<CPDF_Object*>(filespec));
     }
   }
   CPDF_Array* pFields = CPDF_Array::Create();
-  if (pFields == NULL) {
+  if (!pFields) {
     return NULL;
   }
   pMainDict->SetAt("Fields", pFields);
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; i++) {
     CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
-    if (pField == NULL || pField->GetType() == CPDF_FormField::PushButton) {
+    if (!pField || pField->GetType() == CPDF_FormField::PushButton) {
       continue;
     }
     FX_DWORD dwFlags = pField->GetFieldFlags();
     if (dwFlags & 0x04)
       continue;
 
     auto it = std::find(fields.begin(), fields.end(), pField);
     if (bIncludeOrExclude == (it != fields.end())) {
       if ((dwFlags & 0x02) != 0 && pField->m_pDict->GetString("V").IsEmpty())
         continue;
@@ skipping 67 matching lines @@
                                      int nLevel) {
   CFX_WideString name;
   if (!parent_name.IsEmpty()) {
     name = parent_name + L".";
   }
   name += pFieldDict->GetUnicodeText("T");
   CPDF_Array* pKids = pFieldDict->GetArray("Kids");
   if (pKids) {
     for (FX_DWORD i = 0; i < pKids->GetCount(); i++) {
       CPDF_Dictionary* pKid = pKids->GetDict(i);
-      if (pKid == NULL) {
+      if (!pKid) {
         continue;
       }
       if (nLevel <= nMaxRecursion) {
         FDF_ImportField(pKid, name, bNotify, nLevel + 1);
       }
     }
     return;
   }
   if (!pFieldDict->KeyExist("V")) {
     return;
   }
   CPDF_FormField* pField = m_pFieldTree->GetField(name);
-  if (pField == NULL) {
+  if (!pField) {
     return;
   }
   CFX_WideString csWValue;
   FPDFDOC_FDF_GetFieldValue(pFieldDict, csWValue, m_bsEncoding);
   int iType = pField->GetFieldType();
   if (bNotify && m_pFormNotify) {
     int iRet = 0;
     if (iType == FIELDTYPE_LISTBOX) {
       iRet = m_pFormNotify->BeforeSelectionChange(pField, csWValue);
     } else if (iType == FIELDTYPE_COMBOBOX || iType == FIELDTYPE_TEXTFIELD) {
@@ skipping 22 matching lines @@
     } else if (iType == FIELDTYPE_COMBOBOX || iType == FIELDTYPE_TEXTFIELD) {
       m_pFormNotify->AfterValueChange(pField);
     }
   }
   if (CPDF_InterForm::m_bUpdateAP) {
     pField->UpdateAP(NULL);
   }
 }
 FX_BOOL CPDF_InterForm::ImportFromFDF(const CFDF_Document* pFDF,
                                       FX_BOOL bNotify) {
-  if (pFDF == NULL) {
+  if (!pFDF) {
     return FALSE;
   }
   CPDF_Dictionary* pMainDict = pFDF->GetRoot()->GetDict("FDF");
-  if (pMainDict == NULL) {
+  if (!pMainDict) {
     return FALSE;
   }
   CPDF_Array* pFields = pMainDict->GetArray("Fields");
-  if (pFields == NULL) {
+  if (!pFields) {
     return FALSE;
   }
   m_bsEncoding = pMainDict->GetString("Encoding");
   if (bNotify && m_pFormNotify) {
     int iRet = m_pFormNotify->BeforeFormImportData(this);
     if (iRet < 0) {
       return FALSE;
     }
   }
   for (FX_DWORD i = 0; i < pFields->GetCount(); i++) {
     CPDF_Dictionary* pField = pFields->GetDict(i);
-    if (pField == NULL) {
+    if (!pField) {
       continue;
     }
     FDF_ImportField(pField, L"", bNotify);
   }
   if (bNotify && m_pFormNotify) {
     m_pFormNotify->AfterFormImportData(this);
   }
   return TRUE;
 }
 void CPDF_InterForm::SetFormNotify(const CPDF_FormNotify* pNotify) {
   m_pFormNotify = (CPDF_FormNotify*)pNotify;
 }