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

core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.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 "parser_int.h"
 
 #include <set>
 #include <utility>
@@ skipping 249 matching lines @@
     CPDF_Reference* pMetadata =
         ToReference(m_pDocument->GetRoot()->GetElement("Metadata"));
     if (pMetadata)
       m_Syntax.m_MetadataObjnum = pMetadata->GetRefObjNum();
   }
   return PDFPARSE_ERROR_SUCCESS;
 }
 FX_DWORD CPDF_Parser::SetEncryptHandler() {
   ReleaseEncryptHandler();
   SetEncryptDictionary(NULL);
-  if (m_pTrailer == NULL) {
+  if (!m_pTrailer) {
     return PDFPARSE_ERROR_FORMAT;
   }
   CPDF_Object* pEncryptObj = m_pTrailer->GetElement("Encrypt");
   if (pEncryptObj) {
     if (CPDF_Dictionary* pEncryptDict = pEncryptObj->AsDictionary()) {
       SetEncryptDictionary(pEncryptDict);
     } else if (CPDF_Reference* pRef = pEncryptObj->AsReference()) {
       pEncryptObj = m_pDocument->GetIndirectObject(pRef->GetRefObjNum());
       if (pEncryptObj)
         SetEncryptDictionary(pEncryptObj->GetDict());
@@ skipping 54 matching lines @@
     return m_CrossRef[(int32_t)m_CrossRef[objnum]];
   }
   return 0;
 }
 
 FX_BOOL CPDF_Parser::LoadAllCrossRefV4(FX_FILESIZE xrefpos) {
   if (!LoadCrossRefV4(xrefpos, 0, TRUE, FALSE)) {
     return FALSE;
   }
   m_pTrailer = LoadTrailerV4();
-  if (m_pTrailer == NULL) {
+  if (!m_pTrailer) {
     return FALSE;
   }
   int32_t xrefsize = GetDirectInteger(m_pTrailer, "Size");
   if (xrefsize <= 0 || xrefsize > (1 << 20)) {
     return FALSE;
   }
   m_CrossRef.SetSize(xrefsize);
   m_V5Type.SetSize(xrefsize);
   CFX_FileSizeArray CrossRefList, XRefStreamList;
   CrossRefList.Add(xrefpos);
@@ skipping 30 matching lines @@
       return FALSE;
   }
   return TRUE;
 }
 FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV4(FX_FILESIZE xrefpos,
                                                  FX_DWORD dwObjCount) {
   if (!LoadLinearizedCrossRefV4(xrefpos, dwObjCount)) {
     return FALSE;
   }
   m_pTrailer = LoadTrailerV4();
-  if (m_pTrailer == NULL) {
+  if (!m_pTrailer) {
     return FALSE;
   }
   int32_t xrefsize = GetDirectInteger(m_pTrailer, "Size");
   if (xrefsize == 0) {
     return FALSE;
   }
   CFX_FileSizeArray CrossRefList, XRefStreamList;
   CrossRefList.Add(xrefpos);
   XRefStreamList.Add(GetDirectInteger(m_pTrailer, "XRefStm"));
   xrefpos = GetDirectInteger(m_pTrailer, "Prev");
   while (xrefpos) {
     CrossRefList.InsertAt(0, xrefpos);
     LoadCrossRefV4(xrefpos, 0, TRUE, FALSE);
     CPDF_Dictionary* pDict = LoadTrailerV4();
-    if (pDict == NULL) {
+    if (!pDict) {
       return FALSE;
     }
     xrefpos = GetDirectInteger(pDict, "Prev");
     XRefStreamList.InsertAt(0, pDict->GetInteger("XRefStm"));
     m_Trailers.Add(pDict);
   }
   for (int32_t i = 1; i < CrossRefList.GetSize(); i++)
     if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE, i == 0)) {
       return FALSE;
     }
   return TRUE;
 }
 FX_BOOL CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos,
                                               FX_DWORD dwObjCount) {
   FX_FILESIZE dwStartPos = pos - m_Syntax.m_HeaderOffset;
   m_Syntax.RestorePos(dwStartPos);
   void* pResult =
       FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
                     sizeof(FX_FILESIZE), CompareFileSize);
-  if (pResult == NULL) {
+  if (!pResult) {
     m_SortedOffset.Add(pos);
   }
   FX_DWORD start_objnum = 0;
   FX_DWORD count = dwObjCount;
   FX_FILESIZE SavedPos = m_Syntax.SavePos();
   const int32_t recordsize = 20;
   std::vector<char> buf(1024 * recordsize + 1);
   char* pBuf = pdfium::vector_as_array(&buf);
   pBuf[1024 * recordsize] = '\0';
   int32_t nBlocks = count / 1024 + 1;
@@ skipping 23 matching lines @@
         m_CrossRef.SetAtGrow(objnum, offset);
         int32_t version = FXSYS_atoi(pEntry + 11);
         if (version >= 1) {
           m_bVersionUpdated = TRUE;
         }
         m_ObjVersion.SetAtGrow(objnum, version);
         if (m_CrossRef[objnum] < m_Syntax.m_FileLen) {
           void* pResult = FXSYS_bsearch(
               &m_CrossRef[objnum], m_SortedOffset.GetData(),
               m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), CompareFileSize);
-          if (pResult == NULL) {
+          if (!pResult) {
             m_SortedOffset.Add(m_CrossRef[objnum]);
           }
         }
         m_V5Type.SetAtGrow(objnum, 1);
       }
     }
   }
   m_Syntax.RestorePos(SavedPos + count * recordsize);
   return TRUE;
 }
@@ skipping 279 matching lines @@
                 if (objnum > 0x1000000) {
                   status = 0;
                   break;
                 }
                 FX_FILESIZE obj_pos = start_pos - m_Syntax.m_HeaderOffset;
                 last_obj = start_pos;
                 void* pResult =
                     FXSYS_bsearch(&obj_pos, m_SortedOffset.GetData(),
                                   m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
                                   CompareFileSize);
-                if (pResult == NULL) {
+                if (!pResult) {
                   m_SortedOffset.Add(obj_pos);
                 }
                 FX_FILESIZE obj_end = 0;
                 CPDF_Object* pObject = ParseIndirectObjectAtByStrict(
                     m_pDocument, obj_pos, objnum, NULL, &obj_end);
                 if (CPDF_Stream* pStream = ToStream(pObject)) {
                   if (CPDF_Dictionary* pDict = pStream->GetDict()) {
                     if ((pDict->KeyExist("Type")) &&
                         (pDict->GetString("Type") == "XRef" &&
                          pDict->KeyExist("Size"))) {
@@ skipping 181 matching lines @@
   }
   if (last_xref != -1 && last_xref > last_obj) {
     last_trailer = last_xref;
   } else if (last_trailer == -1 || last_xref < last_obj) {
     last_trailer = m_Syntax.m_FileLen;
   }
   FX_FILESIZE offset = last_trailer - m_Syntax.m_HeaderOffset;
   void* pResult =
       FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
                     sizeof(FX_FILESIZE), CompareFileSize);
-  if (pResult == NULL) {
+  if (!pResult) {
     m_SortedOffset.Add(offset);
   }
   FX_Free(buffer);
   return m_pTrailer && m_CrossRef.GetSize() > 0;
 }
 
 FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE* pos, FX_BOOL bMainXRef) {
   CPDF_Object* pObject = ParseIndirectObjectAt(m_pDocument, *pos, 0, nullptr);
   if (!pObject)
     return FALSE;
@@ skipping 41 matching lines @@
         if (nStartNum >= 0 && nCount > 0) {
           arrIndex.push_back(std::make_pair(nStartNum, nCount));
         }
       }
     }
   }
   if (arrIndex.size() == 0) {
     arrIndex.push_back(std::make_pair(0, size));
   }
   pArray = pStream->GetDict()->GetArray("W");
-  if (pArray == NULL) {
+  if (!pArray) {
     pStream->Release();
     return FALSE;
   }
   CFX_DWordArray WidthArray;
   FX_SAFE_DWORD dwAccWidth = 0;
   for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
     WidthArray.Add(pArray->GetInteger(i));
     dwAccWidth += WidthArray[i];
   }
   if (!dwAccWidth.IsValid() || WidthArray.GetSize() < 3) {
@@ skipping 36 matching lines @@
       if (WidthArray[0]) {
         type = GetVarInt(entrystart, WidthArray[0]);
       }
       if (m_V5Type[startnum + j] == 255) {
         FX_FILESIZE offset =
             GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
         m_CrossRef[startnum + j] = offset;
         void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(),
                                       m_SortedOffset.GetSize(),
                                       sizeof(FX_FILESIZE), CompareFileSize);
-        if (pResult == NULL) {
+        if (!pResult) {
           m_SortedOffset.Add(offset);
         }
         continue;
       }
       if (m_V5Type[startnum + j]) {
         continue;
       }
       m_V5Type[startnum + j] = type;
       if (type == 0) {
         m_CrossRef[startnum + j] = 0;
       } else {
         FX_FILESIZE offset =
             GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
         m_CrossRef[startnum + j] = offset;
         if (type == 1) {
           void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(),
                                         m_SortedOffset.GetSize(),
                                         sizeof(FX_FILESIZE), CompareFileSize);
-          if (pResult == NULL) {
+          if (!pResult) {
             m_SortedOffset.Add(offset);
           }
         } else {
           if (offset < 0 || offset >= m_V5Type.GetSize()) {
             pStream->Release();
             return FALSE;
           }
           m_V5Type[offset] = 255;
         }
       }
@@ skipping 32 matching lines @@
   if (m_V5Type[objnum] == 0) {
     return TRUE;
   }
   if (m_V5Type[objnum] == 2) {
     return TRUE;
   }
   FX_FILESIZE pos = m_CrossRef[objnum];
   void* pResult =
       FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
                     sizeof(FX_FILESIZE), CompareFileSize);
-  if (pResult == NULL) {
+  if (!pResult) {
     return TRUE;
   }
   if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)m_SortedOffset.GetData() ==
       m_SortedOffset.GetSize() - 1) {
     return FALSE;
   }
   FX_FILESIZE size = ((FX_FILESIZE*)pResult)[1] - pos;
   FX_FILESIZE SavedPos = m_Syntax.SavePos();
   m_Syntax.RestorePos(pos);
   bForm = m_Syntax.SearchMultiWord("/Form\0stream", TRUE, size) == 0;
@@ skipping 66 matching lines @@
     objnum = (FX_DWORD)m_CrossRef[objnum];
   }
   if (m_V5Type[objnum] == 1 || m_V5Type[objnum] == 255) {
     FX_FILESIZE offset = m_CrossRef[objnum];
     if (offset == 0) {
       return 0;
     }
     void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(),
                                   m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
                                   CompareFileSize);
-    if (pResult == NULL) {
+    if (!pResult) {
       return 0;
     }
     if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)m_SortedOffset.GetData() ==
         m_SortedOffset.GetSize() - 1) {
       return 0;
     }
     return ((FX_FILESIZE*)pResult)[1] - offset;
   }
   return 0;
 }
@@ skipping 62 matching lines @@
     m_Syntax.RestorePos(SavedPos);
     return;
   }
   if (m_Syntax.GetKeyword() != "obj") {
     m_Syntax.RestorePos(SavedPos);
     return;
   }
   void* pResult =
       FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
                     sizeof(FX_FILESIZE), CompareFileSize);
-  if (pResult == NULL) {
+  if (!pResult) {
     m_Syntax.RestorePos(SavedPos);
     return;
   }
   FX_FILESIZE nextoff = ((FX_FILESIZE*)pResult)[1];
   FX_BOOL bNextOffValid = FALSE;
   if (nextoff != pos) {
     m_Syntax.RestorePos(nextoff);
     word = m_Syntax.GetNextWord(bIsNumber);
     if (word == "xref") {
       bNextOffValid = TRUE;
@@ skipping 125 matching lines @@
   if (m_pEncryptDict && m_pEncryptDict->GetString("Filter") == "Standard") {
     dwPermission &= 0xFFFFFFFC;
     dwPermission |= 0xFFFFF0C0;
     if (bCheckRevision && m_pEncryptDict->GetInteger("R") == 2) {
       dwPermission &= 0xFFFFF0FF;
     }
   }
   return dwPermission;
 }
 FX_BOOL CPDF_Parser::IsOwner() {
-  return m_pSecurityHandler == NULL ? TRUE : m_pSecurityHandler->IsOwner();
+  return m_pSecurityHandler ? m_pSecurityHandler->IsOwner() : TRUE;

[Tom Sepez, 2015/12/14 18:27:00]

nit: return !m_pSecurityHandler || m_pSecurityHandler->IsOwner();
(can you tell I don't like TRUE or FALSE appearing in a ? operator)

[Lei Zhang, 2015/12/15 01:58:35]

Mmmmhmm

 }
 void CPDF_Parser::SetSecurityHandler(CPDF_SecurityHandler* pSecurityHandler,
                                      FX_BOOL bForced) {
   m_bForceUseSecurityHandler = bForced;
   m_pSecurityHandler.reset(pSecurityHandler);
   if (m_bForceUseSecurityHandler) {
     return;
   }
   m_Syntax.m_pCryptoHandler.reset(pSecurityHandler->CreateCryptoHandler());
   m_Syntax.m_pCryptoHandler->Init(NULL, pSecurityHandler);
@@ skipping 73 matching lines @@
   if (!(bLoadV4 = LoadCrossRefV4(dwFirstXRefOffset, 0, FALSE, FALSE)) &&
       !LoadCrossRefV5(&dwFirstXRefOffset, TRUE)) {
     if (!RebuildCrossRef()) {
       return PDFPARSE_ERROR_FORMAT;
     }
     bXRefRebuilt = TRUE;
     m_LastXRefOffset = 0;
   }
   if (bLoadV4) {
     m_pTrailer = LoadTrailerV4();
-    if (m_pTrailer == NULL) {
+    if (!m_pTrailer) {
       return FALSE;
     }
     int32_t xrefsize = GetDirectInteger(m_pTrailer, "Size");
     if (xrefsize > 0) {
       m_CrossRef.SetSize(xrefsize);
       m_V5Type.SetSize(xrefsize);
     }
   }
   FX_DWORD dwRet = SetEncryptHandler();
   if (dwRet != PDFPARSE_ERROR_SUCCESS) {
     return dwRet;
   }
   m_pDocument->LoadAsynDoc(m_pLinearized->GetDict());
-  if (m_pDocument->GetRoot() == NULL || m_pDocument->GetPageCount() == 0) {
+  if (!m_pDocument->GetRoot() || m_pDocument->GetPageCount() == 0) {
     if (bXRefRebuilt) {
       return PDFPARSE_ERROR_FORMAT;
     }
     ReleaseEncryptHandler();
     if (!RebuildCrossRef()) {
       return PDFPARSE_ERROR_FORMAT;
     }
     dwRet = SetEncryptHandler();
     if (dwRet != PDFPARSE_ERROR_SUCCESS) {
       return dwRet;
     }
     m_pDocument->LoadAsynDoc(m_pLinearized->GetDict());
-    if (m_pDocument->GetRoot() == NULL) {
+    if (!m_pDocument->GetRoot()) {
       return PDFPARSE_ERROR_FORMAT;
     }
   }
   FXSYS_qsort(m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
               sizeof(FX_FILESIZE), CompareFileSize);
   if (GetRootObjNum() == 0) {
     ReleaseEncryptHandler();
     if (!RebuildCrossRef() || GetRootObjNum() == 0)
       return PDFPARSE_ERROR_FORMAT;
 
@@ skipping 1349 matching lines @@
   int iSize = m_arrayAcroforms.GetSize();
   for (int i = 0; i < iSize; ++i) {
     m_arrayAcroforms.GetAt(i)->Release();
   }
 }
 void CPDF_DataAvail::SetDocument(CPDF_Document* pDoc) {
   m_pDocument = pDoc;
 }
 FX_DWORD CPDF_DataAvail::GetObjectSize(FX_DWORD objnum, FX_FILESIZE& offset) {
   CPDF_Parser* pParser = (CPDF_Parser*)(m_pDocument->GetParser());
-  if (pParser == NULL) {
+  if (!pParser) {
     return 0;
   }
   if (objnum >= (FX_DWORD)pParser->m_CrossRef.GetSize()) {
     return 0;
   }
   if (pParser->m_V5Type[objnum] == 2) {
     objnum = (FX_DWORD)pParser->m_CrossRef[objnum];
   }
   if (pParser->m_V5Type[objnum] == 1 || pParser->m_V5Type[objnum] == 255) {
     offset = pParser->m_CrossRef[objnum];
     if (offset == 0) {
       return 0;
     }
     void* pResult = FXSYS_bsearch(&offset, pParser->m_SortedOffset.GetData(),
                                   pParser->m_SortedOffset.GetSize(),
                                   sizeof(FX_FILESIZE), CompareFileSize);
-    if (pResult == NULL) {
+    if (!pResult) {
       return 0;
     }
     if ((FX_FILESIZE*)pResult -
             (FX_FILESIZE*)pParser->m_SortedOffset.GetData() ==
         pParser->m_SortedOffset.GetSize() - 1) {
       return 0;
     }
     return (FX_DWORD)(((FX_FILESIZE*)pResult)[1] - offset);
   }
   return 0;
@@ skipping 233 matching lines @@
 CPDF_Object* CPDF_DataAvail::GetObject(FX_DWORD objnum,
                                        IFX_DownloadHints* pHints,
                                        FX_BOOL* pExistInFile) {
   CPDF_Object* pRet = nullptr;
   FX_DWORD size = 0;
   FX_FILESIZE offset = 0;
   CPDF_Parser* pParser = nullptr;
   if (pExistInFile)
     *pExistInFile = TRUE;
 
-  if (m_pDocument == NULL) {
+  if (m_pDocument) {
+    size = GetObjectSize(objnum, offset);
+    pParser = (CPDF_Parser*)(m_pDocument->GetParser());
+  } else {
     size = (FX_DWORD)m_parser.GetObjectSize(objnum);
     offset = m_parser.GetObjectOffset(objnum);
     pParser = &m_parser;
-  } else {
-    size = GetObjectSize(objnum, offset);
-    pParser = (CPDF_Parser*)(m_pDocument->GetParser());
   }
   if (!IsDataAvail(offset, size, pHints)) {
     return nullptr;
   }
   if (pParser) {
     pRet = pParser->ParseIndirectObject(NULL, objnum, NULL);
   }
 
   if (!pRet && pExistInFile) {
     *pExistInFile = FALSE;
@@ skipping 1676 matching lines @@
   if (!m_pLinearizedDict)
     return -1;
   CPDF_Array* pRange = m_pLinearizedDict->GetArray("H");
   if (!pRange)
     return -1;
   CPDF_Object* pStreamLen = pRange->GetElementValue(1);
   if (!pStreamLen)
     return -1;
   return pStreamLen->GetInteger();
 }