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

core/src/fxcrt/fx_basic_maps.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/fxcrt/fx_basic.h"
 #include "plex.h"
 
 CFX_MapPtrToPtr::CFX_MapPtrToPtr(int nBlockSize)
@@ skipping 16 matching lines @@
 CFX_MapPtrToPtr::~CFX_MapPtrToPtr() {
   RemoveAll();
   ASSERT(m_nCount == 0);
 }
 FX_DWORD CFX_MapPtrToPtr::HashKey(void* key) const {
   return ((FX_DWORD)(uintptr_t)key) >> 4;
 }
 void CFX_MapPtrToPtr::GetNextAssoc(FX_POSITION& rNextPosition,
                                    void*& rKey,
                                    void*& rValue) const {
-  ASSERT(m_pHashTable != NULL);
+  ASSERT(m_pHashTable);
   CAssoc* pAssocRet = (CAssoc*)rNextPosition;
-  ASSERT(pAssocRet != NULL);
+  ASSERT(pAssocRet);
   if (pAssocRet == (CAssoc*)-1) {
-    for (FX_DWORD nBucket = 0; nBucket < m_nHashTableSize; nBucket++)
-      if ((pAssocRet = m_pHashTable[nBucket]) != NULL) {
+    for (FX_DWORD nBucket = 0; nBucket < m_nHashTableSize; nBucket++) {
+      if ((pAssocRet = m_pHashTable[nBucket]) != NULL)
         break;
-      }
-    ASSERT(pAssocRet != NULL);
+    }
+    ASSERT(pAssocRet);
   }
   CAssoc* pAssocNext;
   if ((pAssocNext = pAssocRet->pNext) == NULL) {
     for (FX_DWORD nBucket = (HashKey(pAssocRet->key) % m_nHashTableSize) + 1;
          nBucket < m_nHashTableSize; nBucket++) {
       if ((pAssocNext = m_pHashTable[nBucket]) != NULL) {
         break;
       }
     }
   }
@@ skipping 32 matching lines @@
   }
   return pAssoc->value;
 }
 CFX_MapPtrToPtr::CAssoc* CFX_MapPtrToPtr::GetAssocAt(void* key,
                                                      FX_DWORD& nHash) const {
   nHash = HashKey(key) % m_nHashTableSize;
   if (m_pHashTable == NULL) {
     return NULL;
   }
   CAssoc* pAssoc;
-  for (pAssoc = m_pHashTable[nHash]; pAssoc != NULL; pAssoc = pAssoc->pNext) {
-    if (pAssoc->key == key) {
+  for (pAssoc = m_pHashTable[nHash]; pAssoc; pAssoc = pAssoc->pNext) {
+    if (pAssoc->key == key)
       return pAssoc;
-    }
   }
   return NULL;
 }
 CFX_MapPtrToPtr::CAssoc* CFX_MapPtrToPtr::NewAssoc() {
   if (m_pFreeList == NULL) {
     CFX_Plex* newBlock = CFX_Plex::Create(m_pBlocks, m_nBlockSize,
                                           sizeof(CFX_MapPtrToPtr::CAssoc));
     CFX_MapPtrToPtr::CAssoc* pAssoc =
         (CFX_MapPtrToPtr::CAssoc*)newBlock->data();
     pAssoc += m_nBlockSize - 1;
     for (int i = m_nBlockSize - 1; i >= 0; i--, pAssoc--) {
       pAssoc->pNext = m_pFreeList;
       m_pFreeList = pAssoc;
     }
   }
-  ASSERT(m_pFreeList != NULL);
   CFX_MapPtrToPtr::CAssoc* pAssoc = m_pFreeList;
   m_pFreeList = m_pFreeList->pNext;
   m_nCount++;
   ASSERT(m_nCount > 0);
   pAssoc->key = 0;
   pAssoc->value = 0;
   return pAssoc;
 }
 void CFX_MapPtrToPtr::InitHashTable(FX_DWORD nHashSize, FX_BOOL bAllocNow) {
   ASSERT(m_nCount == 0);
   ASSERT(nHashSize > 0);
   FX_Free(m_pHashTable);
   m_pHashTable = NULL;
   if (bAllocNow) {
     m_pHashTable = FX_Alloc(CAssoc*, nHashSize);
   }
   m_nHashTableSize = nHashSize;
 }
 FX_BOOL CFX_MapPtrToPtr::RemoveKey(void* key) {
   if (m_pHashTable == NULL) {
     return FALSE;
   }
   CAssoc** ppAssocPrev;
   ppAssocPrev = &m_pHashTable[HashKey(key) % m_nHashTableSize];
   CAssoc* pAssoc;
-  for (pAssoc = *ppAssocPrev; pAssoc != NULL; pAssoc = pAssoc->pNext) {
+  for (pAssoc = *ppAssocPrev; pAssoc; pAssoc = pAssoc->pNext) {
     if (pAssoc->key == key) {
       *ppAssocPrev = pAssoc->pNext;
       FreeAssoc(pAssoc);
       return TRUE;
     }
     ppAssocPrev = &pAssoc->pNext;
   }
   return FALSE;
 }
 void CFX_MapPtrToPtr::FreeAssoc(CFX_MapPtrToPtr::CAssoc* pAssoc) {
@@ skipping 132 matching lines @@
 FX_BOOL CFX_CMapByteStringToPtr::Lookup(const CFX_ByteStringC& key,
                                         void*& rValue) const {
   void* p = m_Buffer.Iterate(_CMapLookupCallback, (void*)&key);
   if (!p) {
     return FALSE;
   }
   rValue = *(void**)((_CompactString*)p + 1);
   return TRUE;
 }
 void CFX_CMapByteStringToPtr::SetAt(const CFX_ByteStringC& key, void* value) {
-  ASSERT(value != NULL);
-  int index, key_len = key.GetLength();
+  ASSERT(value);
+  int key_len = key.GetLength();
   int size = m_Buffer.GetSize();
-  for (index = 0; index < size; index++) {
+  for (int index = 0; index < size; index++) {
     _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
     if (!_CompactStringSame(pKey, key.GetPtr(), key_len)) {
       continue;
     }
     *(void**)(pKey + 1) = value;
     return;
   }
-  for (index = 0; index < size; index++) {
+  for (int index = 0; index < size; index++) {
     _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
     if (pKey->m_CompactLen) {
       continue;
     }
     _CompactStringStore(pKey, key.GetPtr(), key_len);
     *(void**)(pKey + 1) = value;
     return;
   }
   _CompactString* pKey = (_CompactString*)m_Buffer.Add();
   _CompactStringStore(pKey, key.GetPtr(), key_len);
   *(void**)(pKey + 1) = value;
 }
 void CFX_CMapByteStringToPtr::AddValue(const CFX_ByteStringC& key,
                                        void* value) {
-  ASSERT(value != NULL);
+  ASSERT(value);
   _CompactString* pKey = (_CompactString*)m_Buffer.Add();
   _CompactStringStore(pKey, key.GetPtr(), key.GetLength());
   *(void**)(pKey + 1) = value;
 }
 void CFX_CMapByteStringToPtr::RemoveKey(const CFX_ByteStringC& key) {
   int key_len = key.GetLength();
   int size = m_Buffer.GetSize();
   for (int index = 0; index < size; index++) {
     _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
     if (!_CompactStringSame(pKey, key.GetPtr(), key_len)) {
       continue;
     }
     _CompactStringRelease(pKey);
     pKey->m_CompactLen = 0xfe;
     return;
   }
 }
 int CFX_CMapByteStringToPtr::GetCount() const {
   int count = 0;
   int size = m_Buffer.GetSize();
   for (int i = 0; i < size; i++) {
     _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(i);
     if (pKey->m_CompactLen != 0xfe) {
       count++;
     }
   }
   return count;
 }